dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467
 468 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 469
 470 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 471 #include <dali/devel-api/adaptor-framework/image-loading.h>
 472
 473 #include <dali/public-api/events/mouse-button.h>
 474
 475 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 476
 477
 478 // add here SWIG version check
 479
 480 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 481 // disable Swig-dependent warnings
 482
 483 // 'identifier1' has C-linkage specified,
 484 // but returns UDT 'identifier2' which is incompatible with C
 485 #pragma warning(disable: 4190)
 486
 487 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 488 #pragma warning(disable: 4800)
 489
 490 // debug info too long etc etc
 491 #pragma warning(disable: 4786)
 492 #endif
 493
 494
 495 #include <stdexcept>
 496
 497
 498 #include <string>
 499
 500
 501 #include <vector>
 502 #include <algorithm>
 503 #include <stdexcept>
 504
 505
 506 #include <map>
 507 #include <algorithm>
 508 #include <stdexcept>
 509
 510
 511 #include <utility>
 512
 513
 514 typedef float floatp;
 515
 516 SWIGINTERN floatp *new_floatp(){
 517   return new float();
 518 }
 519 SWIGINTERN void delete_floatp(floatp *self){
 520   if (self) delete self;
 521 }
 522 SWIGINTERN void floatp_assign(floatp *self,float value){
 523   *self = value;
 524 }
 525 SWIGINTERN float floatp_value(floatp *self){
 526   return *self;
 527 }
 528 SWIGINTERN float *floatp_cast(floatp *self){
 529   return self;
 530 }
 531 SWIGINTERN floatp *floatp_frompointer(float *t){
 532   return (floatp *) t;
 533 }
 534
 535 typedef int intp;
 536
 537 SWIGINTERN intp *new_intp(){
 538   return new int();
 539 }
 540 SWIGINTERN void delete_intp(intp *self){
 541   if (self) delete self;
 542 }
 543 SWIGINTERN void intp_assign(intp *self,int value){
 544   *self = value;
 545 }
 546 SWIGINTERN int intp_value(intp *self){
 547   return *self;
 548 }
 549 SWIGINTERN int *intp_cast(intp *self){
 550   return self;
 551 }
 552 SWIGINTERN intp *intp_frompointer(int *t){
 553   return (intp *) t;
 554 }
 555
 556 typedef double doublep;
 557
 558 SWIGINTERN doublep *new_doublep(){
 559   return new double();
 560 }
 561 SWIGINTERN void delete_doublep(doublep *self){
 562   if (self) delete self;
 563 }
 564 SWIGINTERN void doublep_assign(doublep *self,double value){
 565   *self = value;
 566 }
 567 SWIGINTERN double doublep_value(doublep *self){
 568   return *self;
 569 }
 570 SWIGINTERN double *doublep_cast(doublep *self){
 571   return self;
 572 }
 573 SWIGINTERN doublep *doublep_frompointer(double *t){
 574   return (doublep *) t;
 575 }
 576
 577 typedef unsigned int uintp;
 578
 579 SWIGINTERN uintp *new_uintp(){
 580   return new unsigned int();
 581 }
 582 SWIGINTERN void delete_uintp(uintp *self){
 583   if (self) delete self;
 584 }
 585 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 586   *self = value;
 587 }
 588 SWIGINTERN unsigned int uintp_value(uintp *self){
 589   return *self;
 590 }
 591 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 592   return self;
 593 }
 594 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 595   return (uintp *) t;
 596 }
 597
 598 typedef unsigned short ushortp;
 599
 600 SWIGINTERN ushortp *new_ushortp(){
 601   return new unsigned short();
 602 }
 603 SWIGINTERN void delete_ushortp(ushortp *self){
 604   if (self) delete self;
 605 }
 606 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 607   *self = value;
 608 }
 609 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 610   return *self;
 611 }
 612 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 613   return self;
 614 }
 615 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 616   return (ushortp *) t;
 617 }
 618
 619 unsigned int int_to_uint(int x) {
 620    return (unsigned int) x;
 621 }
 622
 623
 624 using namespace Dali;
 625 using namespace Dali::Toolkit;
 626
 627 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 628 {
 629   bool result = false;
 630   try
 631   {
 632     // C++ code. DALi uses Handle <-> Body design pattern.
 633     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 634     // Handles in DALi can be converted into a boolean type
 635     // to check if the handle has a valid body attached to it.
 636     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 637     if( *self )
 638     {
 639       result = true;
 640     }
 641     else
 642     {
 643       result = false;
 644     }
 645   }
 646   catch (std::out_of_range& e)
 647   {
 648     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 649     return 0;
 650   }
 651   catch (std::exception& e)
 652   {
 653     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 654     return 0;
 655   }
 656   catch (DaliException e)
 657   {
 658     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 659     return 0;
 660   }
 661   catch (...)
 662   {
 663     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 664     return 0;
 665   }
 666   return result;
 667 }
 668
 669 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 670 {
 671   bool result = false;
 672   try
 673   {
 674     // C++ code. Check if two handles reference the same implemtion
 675     if( *self == rhs)
 676     {
 677       result = true;
 678     }
 679     else
 680     {
 681       result = false;
 682     }
 683   }
 684   catch (std::out_of_range& e)
 685   {
 686     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 687     return 0;
 688   }
 689   catch (std::exception& e)
 690   {
 691     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 692     return 0;
 693   }
 694   catch (DaliException e)
 695   {
 696     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 697     return 0;
 698   }
 699   catch (...)
 700   {
 701     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 702     return 0;
 703   }
 704   return result;
 705 }
 706
 707
 708 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 709      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 710    }
 711 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 712      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 713    }
 714 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 715         std::vector< Dali::TouchPoint >* pv = 0;
 716         if (capacity >= 0) {
 717           pv = new std::vector< Dali::TouchPoint >();
 718           pv->reserve(capacity);
 719        } else {
 720           throw std::out_of_range("capacity");
 721        }
 722        return pv;
 723       }
 724 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 725         if (index>=0 && index<(int)self->size())
 726           return (*self)[index];
 727         else
 728           throw std::out_of_range("index");
 729       }
 730 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 737         if (index>=0 && index<(int)self->size())
 738           (*self)[index] = val;
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 743         self->insert(self->end(), values.begin(), values.end());
 744       }
 745 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 746         if (index < 0)
 747           throw std::out_of_range("index");
 748         if (count < 0)
 749           throw std::out_of_range("count");
 750         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 751           throw std::invalid_argument("invalid range");
 752         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 755         if (index>=0 && index<(int)self->size()+1)
 756           self->insert(self->begin()+index, x);
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, values.begin(), values.end());
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 767         if (index>=0 && index<(int)self->size())
 768           self->erase(self->begin() + index);
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 773         if (index < 0)
 774           throw std::out_of_range("index");
 775         if (count < 0)
 776           throw std::out_of_range("count");
 777         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 778           throw std::invalid_argument("invalid range");
 779         self->erase(self->begin()+index, self->begin()+index+count);
 780       }
 781 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 782         if (count < 0)
 783           throw std::out_of_range("count");
 784         return new std::vector< Dali::TouchPoint >(count, value);
 785       }
 786 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 787         std::reverse(self->begin(), self->end());
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 790         if (index < 0)
 791           throw std::out_of_range("index");
 792         if (count < 0)
 793           throw std::out_of_range("count");
 794         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 795           throw std::invalid_argument("invalid range");
 796         std::reverse(self->begin()+index, self->begin()+index+count);
 797       }
 798 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 799         if (index < 0)
 800           throw std::out_of_range("index");
 801         if (index+values.size() > self->size())
 802           throw std::out_of_range("index");
 803         std::copy(values.begin(), values.end(), self->begin()+index);
 804       }
 805 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 806          return self->Empty();
 807       }
 808 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 809         return self->GetConnectionCount();
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 812           self->Connect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Disconnect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 818           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 819 /*@SWIG@*/ self->Emit( arg );
 820       }
 821 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 822          return self->Empty();
 823       }
 824 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825         return self->GetConnectionCount();
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 828           self->Connect( func );
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Disconnect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 834           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 835 /*@SWIG@*/ self->Emit( arg );
 836       }
 837 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 838          return self->Empty();
 839       }
 840 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 841         return self->GetConnectionCount();
 842       }
 843 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 844           self->Connect( func );
 845       }
 846 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 847           self->Disconnect( func );
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 850           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 851 /*@SWIG@*/ self->Emit( arg );
 852       }
 853 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 854          return self->Empty();
 855       }
 856 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857         return self->GetConnectionCount();
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 860           self->Connect( func );
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Disconnect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 866           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 867 /*@SWIG@*/ self->Emit( arg );
 868       }
 869 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 870          return self->Empty();
 871       }
 872 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 873         return self->GetConnectionCount();
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 876           self->Connect( func );
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Disconnect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 882           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 883 /*@SWIG@*/ self->Emit( arg );
 884       }
 885 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 886          return self->Empty();
 887       }
 888 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 889         return self->GetConnectionCount();
 890       }
 891 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 892         self->Connect( func );
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 895         self->Disconnect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 898         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 899 /*@SWIG@*/ self->Emit( arg1, arg2 );
 900       }
 901 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 902          return self->Empty();
 903       }
 904 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 905         return self->GetConnectionCount();
 906       }
 907 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 908         self->Connect( func );
 909       }
 910 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 911         self->Disconnect( func );
 912       }
 913 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 914         return self->Emit( arg1, arg2 );
 915       }
 916 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 917          return self->Empty();
 918       }
 919 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 920         return self->GetConnectionCount();
 921       }
 922 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 923         self->Connect( func );
 924       }
 925 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 926         self->Disconnect( func );
 927       }
 928 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 929         return self->Emit( arg1, arg2 );
 930       }
 931 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 932          return self->Empty();
 933       }
 934 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 935         return self->GetConnectionCount();
 936       }
 937 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 938         self->Connect( func );
 939       }
 940 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 941         self->Disconnect( func );
 942       }
 943 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 944         return self->Emit( arg1, arg2 );
 945       }
 946 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 947          return self->Empty();
 948       }
 949 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 950         return self->GetConnectionCount();
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 953           self->Connect( func );
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Disconnect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 959           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 960 /*@SWIG@*/ self->Emit( arg );
 961       }
 962 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 963          return self->Empty();
 964       }
 965 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 966         return self->GetConnectionCount();
 967       }
 968 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 969           self->Connect( func );
 970       }
 971 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 972           self->Disconnect( func );
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 975           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 976 /*@SWIG@*/ self->Emit( arg );
 977       }
 978 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 979          return self->Empty();
 980       }
 981 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 982         return self->GetConnectionCount();
 983       }
 984 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 985           self->Connect( func );
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 988           self->Disconnect( func );
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 991           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 992 /*@SWIG@*/ self->Emit( arg );
 993       }
 994 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 995          return self->Empty();
 996       }
 997 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 998         return self->GetConnectionCount();
 999       }
1000 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1001           self->Connect( func );
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1004           self->Disconnect( func );
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1007           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1008 /*@SWIG@*/ self->Emit( arg );
1009       }
1010 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1011          return self->Empty();
1012       }
1013 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1014         return self->GetConnectionCount();
1015       }
1016 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1017         self->Connect( func );
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1020         self->Disconnect( func );
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1023         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1024 /*@SWIG@*/ self->Emit( arg1, arg2 );
1025       }
1026 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1027          return self->Empty();
1028       }
1029 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1030         return self->GetConnectionCount();
1031       }
1032 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1033         self->Connect( func );
1034       }
1035 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1036         self->Disconnect( func );
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1039         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1040 /*@SWIG@*/ self->Emit( arg1, arg2 );
1041       }
1042 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1043          return self->Empty();
1044       }
1045 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1046         return self->GetConnectionCount();
1047       }
1048 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1049         self->Connect( func );
1050       }
1051 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1052         self->Disconnect( func );
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1055         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1056 /*@SWIG@*/ self->Emit( arg1, arg2 );
1057       }
1058 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1059          return self->Empty();
1060       }
1061 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062         return self->GetConnectionCount();
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1065           self->Connect( func );
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Disconnect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1071           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1072 /*@SWIG@*/ self->Emit( arg );
1073       }
1074 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1075          return self->Empty();
1076       }
1077 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1078         return self->GetConnectionCount();
1079       }
1080 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1081           return self->Connect( func );
1082       }
1083 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1084           self->Disconnect( func );
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1087           self->Emit( arg1, arg3 );
1088       }
1089 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1090          return self->Empty();
1091       }
1092 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1093         return self->GetConnectionCount();
1094       }
1095 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1096           return self->Connect( func );
1097       }
1098 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1099           self->Disconnect( func );
1100       }
1101 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1102           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1103 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1104       }
1105
1106 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1107          return self->Empty();
1108       }
1109 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1110         return self->GetConnectionCount();
1111       }
1112 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1113           self->Connect( func );
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Disconnect( func );
1117       }
1118 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1119           return self->Emit();
1120       }
1121
1122 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1123         std::vector< unsigned int >* pv = 0;
1124         if (capacity >= 0) {
1125           pv = new std::vector< unsigned int >();
1126           pv->reserve(capacity);
1127        } else {
1128           throw std::out_of_range("capacity");
1129        }
1130        return pv;
1131       }
1132 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1133         if (index>=0 && index<(int)self->size())
1134           return (*self)[index];
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1139         if (index>=0 && index<(int)self->size())
1140           return (*self)[index];
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1145         if (index>=0 && index<(int)self->size())
1146           (*self)[index] = val;
1147         else
1148           throw std::out_of_range("index");
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1151         self->insert(self->end(), values.begin(), values.end());
1152       }
1153 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1154         if (index < 0)
1155           throw std::out_of_range("index");
1156         if (count < 0)
1157           throw std::out_of_range("count");
1158         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1159           throw std::invalid_argument("invalid range");
1160         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, x);
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1169         if (index>=0 && index<(int)self->size()+1)
1170           self->insert(self->begin()+index, values.begin(), values.end());
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1175         if (index>=0 && index<(int)self->size())
1176           self->erase(self->begin() + index);
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (count < 0)
1184           throw std::out_of_range("count");
1185         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1186           throw std::invalid_argument("invalid range");
1187         self->erase(self->begin()+index, self->begin()+index+count);
1188       }
1189 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1190         if (count < 0)
1191           throw std::out_of_range("count");
1192         return new std::vector< unsigned int >(count, value);
1193       }
1194 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1195         std::reverse(self->begin(), self->end());
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1198         if (index < 0)
1199           throw std::out_of_range("index");
1200         if (count < 0)
1201           throw std::out_of_range("count");
1202         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1203           throw std::invalid_argument("invalid range");
1204         std::reverse(self->begin()+index, self->begin()+index+count);
1205       }
1206 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1207         if (index < 0)
1208           throw std::out_of_range("index");
1209         if (index+values.size() > self->size())
1210           throw std::out_of_range("index");
1211         std::copy(values.begin(), values.end(), self->begin()+index);
1212       }
1213 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1214         return std::find(self->begin(), self->end(), value) != self->end();
1215       }
1216 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1217         int index = -1;
1218         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1219         if (it != self->end())
1220           index = (int)(it - self->begin());
1221         return index;
1222       }
1223 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1224         int index = -1;
1225         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1226         if (rit != self->rend())
1227           index = (int)(self->rend() - 1 - rit);
1228         return index;
1229       }
1230 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1231         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1232         if (it != self->end()) {
1233           self->erase(it);
1234           return true;
1235         }
1236         return false;
1237       }
1238 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1239         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1240         if (capacity >= 0) {
1241           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1242           pv->reserve(capacity);
1243        } else {
1244           throw std::out_of_range("capacity");
1245        }
1246        return pv;
1247       }
1248 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1255         if (index>=0 && index<(int)self->size())
1256           return (*self)[index];
1257         else
1258           throw std::out_of_range("index");
1259       }
1260 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1261         if (index>=0 && index<(int)self->size())
1262           (*self)[index] = val;
1263         else
1264           throw std::out_of_range("index");
1265       }
1266 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1267         self->insert(self->end(), values.begin(), values.end());
1268       }
1269 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1270         if (index < 0)
1271           throw std::out_of_range("index");
1272         if (count < 0)
1273           throw std::out_of_range("count");
1274         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1275           throw std::invalid_argument("invalid range");
1276         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1277       }
1278 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, x);
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1285         if (index>=0 && index<(int)self->size()+1)
1286           self->insert(self->begin()+index, values.begin(), values.end());
1287         else
1288           throw std::out_of_range("index");
1289       }
1290 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1291         if (index>=0 && index<(int)self->size())
1292           self->erase(self->begin() + index);
1293         else
1294           throw std::out_of_range("index");
1295       }
1296 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (count < 0)
1300           throw std::out_of_range("count");
1301         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1302           throw std::invalid_argument("invalid range");
1303         self->erase(self->begin()+index, self->begin()+index+count);
1304       }
1305 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1306         if (count < 0)
1307           throw std::out_of_range("count");
1308         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1309       }
1310 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1311         std::reverse(self->begin(), self->end());
1312       }
1313 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1314         if (index < 0)
1315           throw std::out_of_range("index");
1316         if (count < 0)
1317           throw std::out_of_range("count");
1318         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1319           throw std::invalid_argument("invalid range");
1320         std::reverse(self->begin()+index, self->begin()+index+count);
1321       }
1322 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1323         if (index < 0)
1324           throw std::out_of_range("index");
1325         if (index+values.size() > self->size())
1326           throw std::out_of_range("index");
1327         std::copy(values.begin(), values.end(), self->begin()+index);
1328       }
1329 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1330         std::vector< Dali::Actor >* pv = 0;
1331         if (capacity >= 0) {
1332           pv = new std::vector< Dali::Actor >();
1333           pv->reserve(capacity);
1334        } else {
1335           throw std::out_of_range("capacity");
1336        }
1337        return pv;
1338       }
1339 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1340         if (index>=0 && index<(int)self->size())
1341           return (*self)[index];
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1346         if (index>=0 && index<(int)self->size())
1347           return (*self)[index];
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1352         if (index>=0 && index<(int)self->size())
1353           (*self)[index] = val;
1354         else
1355           throw std::out_of_range("index");
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1358         self->insert(self->end(), values.begin(), values.end());
1359       }
1360 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1361         if (index < 0)
1362           throw std::out_of_range("index");
1363         if (count < 0)
1364           throw std::out_of_range("count");
1365         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1366           throw std::invalid_argument("invalid range");
1367         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, x);
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1376         if (index>=0 && index<(int)self->size()+1)
1377           self->insert(self->begin()+index, values.begin(), values.end());
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1382         if (index>=0 && index<(int)self->size())
1383           self->erase(self->begin() + index);
1384         else
1385           throw std::out_of_range("index");
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (count < 0)
1391           throw std::out_of_range("count");
1392         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1393           throw std::invalid_argument("invalid range");
1394         self->erase(self->begin()+index, self->begin()+index+count);
1395       }
1396 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1397         if (count < 0)
1398           throw std::out_of_range("count");
1399         return new std::vector< Dali::Actor >(count, value);
1400       }
1401 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1402         std::reverse(self->begin(), self->end());
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1405         if (index < 0)
1406           throw std::out_of_range("index");
1407         if (count < 0)
1408           throw std::out_of_range("count");
1409         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1410           throw std::invalid_argument("invalid range");
1411         std::reverse(self->begin()+index, self->begin()+index+count);
1412       }
1413 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1414         if (index < 0)
1415           throw std::out_of_range("index");
1416         if (index+values.size() > self->size())
1417           throw std::out_of_range("index");
1418         std::copy(values.begin(), values.end(), self->begin()+index);
1419       }
1420 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1421          return self->Empty();
1422       }
1423 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424         return self->GetConnectionCount();
1425       }
1426 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1427           self->Connect( func );
1428       }
1429 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1430           self->Disconnect( func );
1431       }
1432 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1433           return self->Emit( arg );
1434       }
1435 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1436          return self->Empty();
1437       }
1438 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1439         return self->GetConnectionCount();
1440       }
1441 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1442         self->Connect( func );
1443       }
1444 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1445         self->Disconnect( func );
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1448         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1449 /*@SWIG@*/ self->Emit( arg1, arg2 );
1450       }
1451 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1452          return self->Empty();
1453       }
1454 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1455         return self->GetConnectionCount();
1456       }
1457 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1458         self->Connect( func );
1459       }
1460 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1461         self->Disconnect( func );
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1464         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1465 /*@SWIG@*/ self->Emit( arg1, arg2 );
1466       }
1467 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1468          return self->Empty();
1469       }
1470 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471         return self->GetConnectionCount();
1472       }
1473 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1474         self->Connect( func );
1475       }
1476 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1477         self->Disconnect( func );
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1480         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1481 /*@SWIG@*/ self->Emit( arg1, arg2 );
1482       }
1483 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1484          return self->Empty();
1485       }
1486 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1487         return self->GetConnectionCount();
1488       }
1489 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1490         self->Connect( func );
1491       }
1492 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1493         self->Disconnect( func );
1494       }
1495 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1496         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1497 /*@SWIG@*/ self->Emit( arg1, arg2 );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1506           self->Connect( func );
1507       }
1508 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1512           return self->Emit( arg );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1515          return self->Empty();
1516       }
1517 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518         return self->GetConnectionCount();
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1521           self->Connect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1524           self->Disconnect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1527           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1528 /*@SWIG@*/ self->Emit( arg );
1529       }
1530 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1531          return self->Empty();
1532       }
1533 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1534         return self->GetConnectionCount();
1535       }
1536 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1537           return self->Connect( func );
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1540           self->Disconnect( func );
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1543           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1544 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1545       }
1546 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1547          return self->Empty();
1548       }
1549 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550         return self->GetConnectionCount();
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1553           self->Connect( func );
1554       }
1555 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1556           self->Disconnect( func );
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1559           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1560 /*@SWIG@*/ self->Emit( arg );
1561       }
1562 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1563          return self->Empty();
1564       }
1565 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1566         return self->GetConnectionCount();
1567       }
1568 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1569           return self->Connect( func );
1570       }
1571 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1572           self->Disconnect( func );
1573       }
1574 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1575           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1576 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1577       }
1578 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1579          return self->Empty();
1580       }
1581 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1582         return self->GetConnectionCount();
1583       }
1584 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1585           self->Connect( func );
1586       }
1587 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1588           self->Disconnect( func );
1589       }
1590 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1591           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1592 /*@SWIG@*/ self->Emit( arg );
1593       }
1594 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1595          return self->Empty();
1596       }
1597 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1598         return self->GetConnectionCount();
1599       }
1600 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1601           self->Connect( func );
1602       }
1603 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1604           self->Disconnect( func );
1605       }
1606 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1607           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1608 /*@SWIG@*/ self->Emit( arg );
1609       }
1610
1611
1612 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1613          return self->Empty();
1614       }
1615 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1616         return self->GetConnectionCount();
1617       }
1618 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1619         self->Connect( func );
1620       }
1621 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1622         self->Disconnect( func );
1623       }
1624 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1625         return self->Emit( arg1, arg2 );
1626       }
1627 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1628          return self->Empty();
1629       }
1630 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631         return self->GetConnectionCount();
1632       }
1633 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1634           self->Connect( func );
1635       }
1636 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1637           self->Disconnect( func );
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1640           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1641 /*@SWIG@*/ self->Emit( arg );
1642       }
1643 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1644          return self->Empty();
1645       }
1646 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647         return self->GetConnectionCount();
1648       }
1649 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1650           self->Connect( func );
1651       }
1652 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1653           self->Disconnect( func );
1654       }
1655 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1656           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1657 /*@SWIG@*/ self->Emit( arg );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1660          return self->Empty();
1661       }
1662 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1663         return self->GetConnectionCount();
1664       }
1665 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1666         self->Connect( func );
1667       }
1668 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1669         self->Disconnect( func );
1670       }
1671 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1672         return self->Emit( arg1, arg2 );
1673       }
1674 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1675          return self->Empty();
1676       }
1677 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1678         return self->GetConnectionCount();
1679       }
1680 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1681         self->Connect( func );
1682       }
1683 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1684         self->Disconnect( func );
1685       }
1686 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1687         return self->Emit( arg1, arg2 );
1688       }
1689
1690 /* ---------------------------------------------------
1691  * C++ director class methods
1692  * --------------------------------------------------- */
1693
1694 #include "dali_wrap.h"
1695
1696 /*
1697  *  Widget director
1698  */
1699 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1700   swig_init_callbacks();
1701 }
1702
1703 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1704 }
1705
1706 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1707   char * jcontentInfo = 0 ;
1708   void * jwindow  ;
1709
1710   if (!swig_callbackOnCreate) {
1711     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1712     return;
1713   } else {
1714     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1715     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1716     swig_callbackOnCreate(jcontentInfo, jwindow);
1717   }
1718 }
1719
1720 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1721   char * jcontentInfo = 0 ;
1722   int jtype  ;
1723
1724   if (!swig_callbackOnTerminate) {
1725     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1726     return;
1727   } else {
1728     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1729     jtype = (int)type;
1730     swig_callbackOnTerminate(jcontentInfo, jtype);
1731   }
1732 }
1733
1734 void SwigDirector_WidgetImpl::OnPause() {
1735   if (!swig_callbackOnPause) {
1736     Dali::Internal::Adaptor::Widget::OnPause();
1737     return;
1738   } else {
1739     swig_callbackOnPause();
1740   }
1741 }
1742
1743 void SwigDirector_WidgetImpl::OnResume() {
1744   if (!swig_callbackOnResume) {
1745     Dali::Internal::Adaptor::Widget::OnResume();
1746     return;
1747   } else {
1748     swig_callbackOnResume();
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1753   void * jwindow  ;
1754
1755   if (!swig_callbackOnResize) {
1756     Dali::Internal::Adaptor::Widget::OnResize(window);
1757     return;
1758   } else {
1759     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1760     swig_callbackOnResize(jwindow);
1761   }
1762 }
1763
1764 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1765   char * jcontentInfo = 0 ;
1766   int jforce  ;
1767
1768   if (!swig_callbackOnUpdate) {
1769     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1770     return;
1771   } else {
1772     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1773     jforce = force;
1774     swig_callbackOnUpdate(jcontentInfo, jforce);
1775   }
1776 }
1777
1778 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1779   void * jslotObserver = 0 ;
1780   void * jcallback = 0 ;
1781
1782   if (!swig_callbackSignalConnected) {
1783     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1784     return;
1785   } else {
1786     jslotObserver = (void *) slotObserver;
1787     jcallback = (void *) callback;
1788     swig_callbackSignalConnected(jslotObserver, jcallback);
1789   }
1790 }
1791
1792 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1793   void * jslotObserver = 0 ;
1794   void * jcallback = 0 ;
1795
1796   if (!swig_callbackSignalDisconnected) {
1797     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1798     return;
1799   } else {
1800     jslotObserver = (void *) slotObserver;
1801     jcallback = (void *) callback;
1802     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1803   }
1804 }
1805
1806 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1807
1808   swig_callbackOnCreate = callbackOnCreate;
1809   swig_callbackOnTerminate = callbackOnTerminate;
1810   swig_callbackOnPause = callbackOnPause;
1811   swig_callbackOnResume = callbackOnResume;
1812   swig_callbackOnResize = callbackOnResize;
1813   swig_callbackOnUpdate = callbackOnUpdate;
1814   swig_callbackSignalConnected = callbackSignalConnected;
1815   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1816 }
1817
1818 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1819   swig_callbackOnCreate = 0;
1820   swig_callbackOnTerminate = 0;
1821   swig_callbackOnPause = 0;
1822   swig_callbackOnResume = 0;
1823   swig_callbackOnResize = 0;
1824   swig_callbackOnUpdate = 0;
1825   swig_callbackSignalConnected = 0;
1826   swig_callbackSignalDisconnected = 0;
1827 }
1828
1829
1830 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1831   swig_init_callbacks();
1832 }
1833
1834 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1835
1836 }
1837
1838
1839 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1840   int jdepth  ;
1841
1842   if (!swig_callbackOnStageConnection) {
1843     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1844     return;
1845   } else {
1846     jdepth = depth;
1847     swig_callbackOnStageConnection(jdepth);
1848   }
1849 }
1850
1851 void SwigDirector_ViewImpl::OnStageDisconnection() {
1852   if (!swig_callbackOnStageDisconnection) {
1853     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1854     return;
1855   } else {
1856     swig_callbackOnStageDisconnection();
1857   }
1858 }
1859
1860 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1861   void * jchild = 0 ;
1862
1863   if (!swig_callbackOnChildAdd) {
1864     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1865     return;
1866   } else {
1867     jchild = (Dali::Actor *) &child;
1868     swig_callbackOnChildAdd(jchild);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1873   void * jchild = 0 ;
1874
1875   if (!swig_callbackOnChildRemove) {
1876     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1877     return;
1878   } else {
1879     jchild = (Dali::Actor *) &child;
1880     swig_callbackOnChildRemove(jchild);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1885   int jindex  ;
1886   void * jpropertyValue  ;
1887
1888   if (!swig_callbackOnPropertySet) {
1889     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1890     return;
1891   } else {
1892     jindex = index;
1893     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1894     swig_callbackOnPropertySet(jindex, jpropertyValue);
1895   }
1896 }
1897
1898 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1899   void * jtargetSize = 0 ;
1900
1901   if (!swig_callbackOnSizeSet) {
1902     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1903     return;
1904   } else {
1905     jtargetSize = (Dali::Vector3 *) &targetSize;
1906     swig_callbackOnSizeSet(jtargetSize);
1907   }
1908 }
1909
1910 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1911   void * janimation = 0 ;
1912   void * jtargetSize = 0 ;
1913
1914   if (!swig_callbackOnSizeAnimation) {
1915     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1916     return;
1917   } else {
1918     janimation = (Dali::Animation *) &animation;
1919     jtargetSize = (Dali::Vector3 *) &targetSize;
1920     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1921   }
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnTouchEvent) {
1930     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1931   } else {
1932     jarg0 = (Dali::TouchEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnHoverEvent) {
1945     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1946   } else {
1947     jarg0 = (Dali::HoverEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1955   bool c_result = SwigValueInit< bool >() ;
1956   unsigned int jresult = 0 ;
1957   void * jarg0 = 0 ;
1958
1959   if (!swig_callbackOnKeyEvent) {
1960     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1961   } else {
1962     jarg0 = (Dali::KeyEvent *) &event;
1963     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1964     c_result = jresult ? true : false;
1965   }
1966   return c_result;
1967 }
1968
1969 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1970   bool c_result = SwigValueInit< bool >() ;
1971   unsigned int jresult = 0 ;
1972   void * jarg0 = 0 ;
1973
1974   if (!swig_callbackOnWheelEvent) {
1975     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1976   } else {
1977     jarg0 = (Dali::WheelEvent *) &event;
1978     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1979     c_result = jresult ? true : false;
1980   }
1981   return c_result;
1982 }
1983
1984 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1985   void * jsize = 0 ;
1986   void * jcontainer = 0 ;
1987
1988   if (!swig_callbackOnRelayout) {
1989     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1990     return;
1991   } else {
1992     jsize = (Dali::Vector2 *) &size;
1993     jcontainer = (Dali::RelayoutContainer *) &container;
1994     swig_callbackOnRelayout(jsize, jcontainer);
1995   }
1996 }
1997
1998 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1999   int jpolicy  ;
2000   int jdimension  ;
2001
2002   if (!swig_callbackOnSetResizePolicy) {
2003     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2004     return;
2005   } else {
2006     jpolicy = (int)policy;
2007     jdimension = (int)dimension;
2008     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2009   }
2010 }
2011
2012 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2013   Dali::Vector3 c_result ;
2014   void * jresult = 0 ;
2015
2016   if (!swig_callbackGetNaturalSize) {
2017     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2018   } else {
2019     jresult = (void *) swig_callbackGetNaturalSize();
2020     if (!jresult) {
2021       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2022       return c_result;
2023     }
2024     c_result = *(Dali::Vector3 *)jresult;
2025   }
2026   return c_result;
2027 }
2028
2029 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2030   float c_result = SwigValueInit< float >() ;
2031   float jresult = 0 ;
2032   void * jchild = 0 ;
2033   int jdimension  ;
2034
2035   if (!swig_callbackCalculateChildSize) {
2036     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2037   } else {
2038     jchild = (Dali::Actor *) &child;
2039     jdimension = (int)dimension;
2040     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2047   float c_result = SwigValueInit< float >() ;
2048   float jresult = 0 ;
2049   float jwidth  ;
2050
2051   if (!swig_callbackGetHeightForWidth) {
2052     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2053   } else {
2054     jwidth = width;
2055     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2056     c_result = (float)jresult;
2057   }
2058   return c_result;
2059 }
2060
2061 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2062   float c_result = SwigValueInit< float >() ;
2063   float jresult = 0 ;
2064   float jheight  ;
2065
2066   if (!swig_callbackGetWidthForHeight) {
2067     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2068   } else {
2069     jheight = height;
2070     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2071     c_result = (float)jresult;
2072   }
2073   return c_result;
2074 }
2075
2076 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2077   bool c_result = SwigValueInit< bool >() ;
2078   unsigned int jresult = 0 ;
2079   int jdimension  ;
2080
2081   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2082     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2083   } else {
2084     jdimension = (int)dimension;
2085     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2086     c_result = jresult ? true : false;
2087   }
2088   return c_result;
2089 }
2090
2091 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2092   int jdimension  ;
2093
2094   if (!swig_callbackOnCalculateRelayoutSize) {
2095     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2096     return;
2097   } else {
2098     jdimension = (int)dimension;
2099     swig_callbackOnCalculateRelayoutSize(jdimension);
2100   }
2101 }
2102
2103 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2104   float jsize  ;
2105   int jdimension  ;
2106
2107   if (!swig_callbackOnLayoutNegotiated) {
2108     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2109     return;
2110   } else {
2111     jsize = size;
2112     jdimension = (int)dimension;
2113     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2114   }
2115 }
2116
2117 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2118   return Dali::CustomActorImpl::GetExtension();
2119 }
2120
2121 void SwigDirector_ViewImpl::OnInitialize() {
2122   if (!swig_callbackOnInitialize) {
2123     Dali::Toolkit::Internal::Control::OnInitialize();
2124     return;
2125   } else {
2126     swig_callbackOnInitialize();
2127   }
2128 }
2129
2130 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2131   void * jchild = 0 ;
2132
2133   if (!swig_callbackOnControlChildAdd) {
2134     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2135     return;
2136   } else {
2137     jchild = (Dali::Actor *) &child;
2138     swig_callbackOnControlChildAdd(jchild);
2139   }
2140 }
2141
2142 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2143   void * jchild = 0 ;
2144
2145   if (!swig_callbackOnControlChildRemove) {
2146     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2147     return;
2148   } else {
2149     jchild = (Dali::Actor *) &child;
2150     swig_callbackOnControlChildRemove(jchild);
2151   }
2152 }
2153
2154 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2155   void * jstyleManager  ;
2156   int jchange  ;
2157
2158   if (!swig_callbackOnStyleChange) {
2159     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2160     return;
2161   } else {
2162     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2163     jchange = (int)change;
2164     swig_callbackOnStyleChange(jstyleManager, jchange);
2165   }
2166 }
2167
2168 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2169   bool c_result = SwigValueInit< bool >() ;
2170   unsigned int jresult = 0 ;
2171
2172   if (!swig_callbackOnAccessibilityActivated) {
2173     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2174   } else {
2175     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2176     c_result = jresult ? true : false;
2177   }
2178   return c_result;
2179 }
2180
2181 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2182   bool c_result = SwigValueInit< bool >() ;
2183   unsigned int jresult = 0 ;
2184   void * jgesture  ;
2185
2186   if (!swig_callbackOnAccessibilityPan) {
2187     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2188   } else {
2189     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2190     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2191     c_result = jresult ? true : false;
2192   }
2193   return c_result;
2194 }
2195
2196 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2197   bool c_result = SwigValueInit< bool >() ;
2198   unsigned int jresult = 0 ;
2199   void * jtouchEvent = 0 ;
2200
2201   if (!swig_callbackOnAccessibilityTouch) {
2202     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2203   } else {
2204     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2205     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2206     c_result = jresult ? true : false;
2207   }
2208   return c_result;
2209 }
2210
2211 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2212   bool c_result = SwigValueInit< bool >() ;
2213   unsigned int jresult = 0 ;
2214   unsigned int jisIncrease  ;
2215
2216   if (!swig_callbackOnAccessibilityValueChange) {
2217     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2218   } else {
2219     jisIncrease = isIncrease;
2220     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2221     c_result = jresult ? true : false;
2222   }
2223   return c_result;
2224 }
2225
2226 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2227   bool c_result = SwigValueInit< bool >() ;
2228   unsigned int jresult = 0 ;
2229
2230   if (!swig_callbackOnAccessibilityZoom) {
2231     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2232   } else {
2233     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2234     c_result = jresult ? true : false;
2235   }
2236   return c_result;
2237 }
2238
2239 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2240   if (!swig_callbackOnKeyInputFocusGained) {
2241     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2242     return;
2243   } else {
2244     swig_callbackOnKeyInputFocusGained();
2245   }
2246 }
2247
2248 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2249   if (!swig_callbackOnKeyInputFocusLost) {
2250     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2251     return;
2252   } else {
2253     swig_callbackOnKeyInputFocusLost();
2254   }
2255 }
2256
2257 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2258   Dali::Actor c_result ;
2259   void * jresult = 0 ;
2260   void * jcurrentFocusedActor  ;
2261   int jdirection  ;
2262   unsigned int jloopEnabled  ;
2263
2264   if (!swig_callbackGetNextKeyboardFocusableActor) {
2265     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2266   } else {
2267     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2268     jdirection = (int)direction;
2269     jloopEnabled = loopEnabled;
2270     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2271     if (!jresult) {
2272       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2273       return c_result;
2274     }
2275     c_result = *(Dali::Actor *)jresult;
2276   }
2277   return c_result;
2278 }
2279
2280 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2281   void * jcommitedFocusableActor  ;
2282
2283   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2284     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2285     return;
2286   } else {
2287     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2288     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2289   }
2290 }
2291
2292 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2293   bool c_result = SwigValueInit< bool >() ;
2294   unsigned int jresult = 0 ;
2295
2296   if (!swig_callbackOnKeyboardEnter) {
2297     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2298   } else {
2299     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2300     c_result = jresult ? true : false;
2301   }
2302   return c_result;
2303 }
2304
2305 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2306   void * jpinch = 0 ;
2307
2308   if (!swig_callbackOnPinch) {
2309     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2310     return;
2311   } else {
2312     jpinch = (Dali::PinchGesture *) &pinch;
2313     swig_callbackOnPinch(jpinch);
2314   }
2315 }
2316
2317 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2318   void * jpan = 0 ;
2319
2320   if (!swig_callbackOnPan) {
2321     Dali::Toolkit::Internal::Control::OnPan(pan);
2322     return;
2323   } else {
2324     jpan = (Dali::PanGesture *) &pan;
2325     swig_callbackOnPan(jpan);
2326   }
2327 }
2328
2329 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2330   void * jtap = 0 ;
2331
2332   if (!swig_callbackOnTap) {
2333     Dali::Toolkit::Internal::Control::OnTap(tap);
2334     return;
2335   } else {
2336     jtap = (Dali::TapGesture *) &tap;
2337     swig_callbackOnTap(jtap);
2338   }
2339 }
2340
2341 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2342   void * jlongPress = 0 ;
2343
2344   if (!swig_callbackOnLongPress) {
2345     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2346     return;
2347   } else {
2348     jlongPress = (Dali::LongPressGesture *) &longPress;
2349     swig_callbackOnLongPress(jlongPress);
2350   }
2351 }
2352
2353 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2354   void * jslotObserver = 0 ;
2355   void * jcallback = 0 ;
2356
2357   if (!swig_callbackSignalConnected) {
2358     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2359     return;
2360   } else {
2361     jslotObserver = (void *) slotObserver;
2362     jcallback = (void *) callback;
2363     swig_callbackSignalConnected(jslotObserver, jcallback);
2364   }
2365 }
2366
2367 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2368   void * jslotObserver = 0 ;
2369   void * jcallback = 0 ;
2370
2371   if (!swig_callbackSignalDisconnected) {
2372     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2373     return;
2374   } else {
2375     jslotObserver = (void *) slotObserver;
2376     jcallback = (void *) callback;
2377     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2378   }
2379 }
2380
2381 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2382   return Dali::Toolkit::Internal::Control::GetControlExtension();
2383 }
2384
2385 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2386   swig_callbackOnStageConnection = callbackOnStageConnection;
2387   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2388   swig_callbackOnChildAdd = callbackOnChildAdd;
2389   swig_callbackOnChildRemove = callbackOnChildRemove;
2390   swig_callbackOnPropertySet = callbackOnPropertySet;
2391   swig_callbackOnSizeSet = callbackOnSizeSet;
2392   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2393   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2394   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2395   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2396   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2397   swig_callbackOnRelayout = callbackOnRelayout;
2398   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2399   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2400   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2401   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2402   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2403   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2405   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2406   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2407   swig_callbackOnInitialize = callbackOnInitialize;
2408   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2409   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2410   swig_callbackOnStyleChange = callbackOnStyleChange;
2411   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2412   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2413   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2414   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2415   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2416   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2417   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2418   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2419   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2420   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2421   swig_callbackOnPinch = callbackOnPinch;
2422   swig_callbackOnPan = callbackOnPan;
2423   swig_callbackOnTap = callbackOnTap;
2424   swig_callbackOnLongPress = callbackOnLongPress;
2425   swig_callbackSignalConnected = callbackSignalConnected;
2426   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2427 }
2428
2429 void SwigDirector_ViewImpl::swig_init_callbacks() {
2430   swig_callbackOnStageConnection = 0;
2431   swig_callbackOnStageDisconnection = 0;
2432   swig_callbackOnChildAdd = 0;
2433   swig_callbackOnChildRemove = 0;
2434   swig_callbackOnPropertySet = 0;
2435   swig_callbackOnSizeSet = 0;
2436   swig_callbackOnSizeAnimation = 0;
2437   swig_callbackOnTouchEvent = 0;
2438   swig_callbackOnHoverEvent = 0;
2439   swig_callbackOnKeyEvent = 0;
2440   swig_callbackOnWheelEvent = 0;
2441   swig_callbackOnRelayout = 0;
2442   swig_callbackOnSetResizePolicy = 0;
2443   swig_callbackGetNaturalSize = 0;
2444   swig_callbackCalculateChildSize = 0;
2445   swig_callbackGetHeightForWidth = 0;
2446   swig_callbackGetWidthForHeight = 0;
2447   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2449   swig_callbackOnCalculateRelayoutSize = 0;
2450   swig_callbackOnLayoutNegotiated = 0;
2451   swig_callbackOnInitialize = 0;
2452   swig_callbackOnControlChildAdd = 0;
2453   swig_callbackOnControlChildRemove = 0;
2454   swig_callbackOnStyleChange = 0;
2455   swig_callbackOnAccessibilityActivated = 0;
2456   swig_callbackOnAccessibilityPan = 0;
2457   swig_callbackOnAccessibilityTouch = 0;
2458   swig_callbackOnAccessibilityValueChange = 0;
2459   swig_callbackOnAccessibilityZoom = 0;
2460   swig_callbackOnKeyInputFocusGained = 0;
2461   swig_callbackOnKeyInputFocusLost = 0;
2462   swig_callbackGetNextKeyboardFocusableActor = 0;
2463   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2464   swig_callbackOnKeyboardEnter = 0;
2465   swig_callbackOnPinch = 0;
2466   swig_callbackOnPan = 0;
2467   swig_callbackOnTap = 0;
2468   swig_callbackOnLongPress = 0;
2469   swig_callbackSignalConnected = 0;
2470   swig_callbackSignalDisconnected = 0;
2471 }
2472
2473 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2474   swig_init_callbacks();
2475 }
2476
2477 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2478
2479 }
2480
2481
2482 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2483   unsigned int c_result = SwigValueInit< unsigned int >() ;
2484   unsigned int jresult = 0 ;
2485
2486   if (!swig_callbackGetNumberOfItems) {
2487     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2488   } else {
2489     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2490     c_result = (unsigned int)jresult;
2491   }
2492   return c_result;
2493 }
2494
2495 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2496   Dali::Actor c_result ;
2497   void * jresult = 0 ;
2498   unsigned int jitemId  ;
2499
2500   if (!swig_callbackNewItem) {
2501     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2502   } else {
2503     jitemId = itemId;
2504     jresult = (void *) swig_callbackNewItem(jitemId);
2505     if (!jresult) {
2506       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2507       return c_result;
2508     }
2509     c_result = *(Dali::Actor *)jresult;
2510   }
2511   return c_result;
2512 }
2513
2514 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2515   unsigned int jitemId  ;
2516   void * jactor  ;
2517
2518   if (!swig_callbackItemReleased) {
2519     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2520     return;
2521   } else {
2522     jitemId = itemId;
2523     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2524     swig_callbackItemReleased(jitemId, jactor);
2525   }
2526 }
2527
2528 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2529   return Dali::Toolkit::ItemFactory::GetExtension();
2530 }
2531
2532 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2533   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2534   swig_callbackNewItem = callbackNewItem;
2535   swig_callbackItemReleased = callbackItemReleased;
2536 }
2537
2538 void SwigDirector_ItemFactory::swig_init_callbacks() {
2539   swig_callbackGetNumberOfItems = 0;
2540   swig_callbackNewItem = 0;
2541   swig_callbackItemReleased = 0;
2542 }
2543
2544 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2545   swig_init_callbacks();
2546 }
2547
2548 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2549
2550 }
2551
2552
2553 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2554   Dali::Actor c_result ;
2555   void * jresult = 0 ;
2556   void * jcurrent  ;
2557   void * jproposed  ;
2558   int jdirection  ;
2559
2560   if (!swig_callbackGetNextFocusableActor) {
2561     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2562   } else {
2563     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2564     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2565     jdirection = (int)direction;
2566     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2567     if (!jresult) {
2568       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2569       return c_result;
2570     }
2571     c_result = *(Dali::Actor *)jresult;
2572   }
2573   return c_result;
2574 }
2575
2576 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2577   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2578 }
2579
2580 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2581   swig_callbackGetNextFocusableActor = 0;
2582 }
2583
2584
2585 #ifdef __cplusplus
2586 extern "C" {
2587 #endif
2588
2589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2590   void * jresult ;
2591   floatp *result = 0 ;
2592
2593   {
2594     try {
2595       result = (floatp *)new_floatp();
2596     } catch (std::out_of_range& e) {
2597       {
2598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2599       };
2600     } catch (std::exception& e) {
2601       {
2602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (DaliException e) {
2605       {
2606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2611       };
2612     }
2613   }
2614   jresult = (void *)result;
2615   return jresult;
2616 }
2617
2618
2619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2620   floatp *arg1 = (floatp *) 0 ;
2621
2622   arg1 = (floatp *)jarg1;
2623   {
2624     try {
2625       delete_floatp(arg1);
2626     } catch (std::out_of_range& e) {
2627       {
2628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2629       };
2630     } catch (std::exception& e) {
2631       {
2632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2633       };
2634     } catch (Dali::DaliException e) {
2635       {
2636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2637       };
2638     } catch (...) {
2639       {
2640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2641       };
2642     }
2643   }
2644
2645 }
2646
2647
2648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2649   floatp *arg1 = (floatp *) 0 ;
2650   float arg2 ;
2651
2652   arg1 = (floatp *)jarg1;
2653   arg2 = (float)jarg2;
2654   {
2655     try {
2656       floatp_assign(arg1,arg2);
2657     } catch (std::out_of_range& e) {
2658       {
2659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2660       };
2661     } catch (std::exception& e) {
2662       {
2663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2664       };
2665     } catch (Dali::DaliException e) {
2666       {
2667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2668       };
2669     } catch (...) {
2670       {
2671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2672       };
2673     }
2674   }
2675
2676 }
2677
2678
2679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2680   float jresult ;
2681   floatp *arg1 = (floatp *) 0 ;
2682   float result;
2683
2684   arg1 = (floatp *)jarg1;
2685   {
2686     try {
2687       result = (float)floatp_value(arg1);
2688     } catch (std::out_of_range& e) {
2689       {
2690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2691       };
2692     } catch (std::exception& e) {
2693       {
2694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2695       };
2696     } catch (DaliException e) {
2697       {
2698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2699       };
2700     } catch (...) {
2701       {
2702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2703       };
2704     }
2705   }
2706   jresult = result;
2707   return jresult;
2708 }
2709
2710
2711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2712   void * jresult ;
2713   floatp *arg1 = (floatp *) 0 ;
2714   float *result = 0 ;
2715
2716   arg1 = (floatp *)jarg1;
2717   {
2718     try {
2719       result = (float *)floatp_cast(arg1);
2720     } catch (std::out_of_range& e) {
2721       {
2722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2723       };
2724     } catch (std::exception& e) {
2725       {
2726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2727       };
2728     } catch (Dali::DaliException e) {
2729       {
2730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2731       };
2732     } catch (...) {
2733       {
2734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2735       };
2736     }
2737   }
2738
2739   jresult = (void *)result;
2740   return jresult;
2741 }
2742
2743
2744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2745   void * jresult ;
2746   float *arg1 = (float *) 0 ;
2747   floatp *result = 0 ;
2748
2749   arg1 = (float *)jarg1;
2750   {
2751     try {
2752       result = (floatp *)floatp_frompointer(arg1);
2753     } catch (std::out_of_range& e) {
2754       {
2755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2756       };
2757     } catch (std::exception& e) {
2758       {
2759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2760       };
2761     } catch (Dali::DaliException e) {
2762       {
2763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2764       };
2765     } catch (...) {
2766       {
2767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2768       };
2769     }
2770   }
2771
2772   jresult = (void *)result;
2773   return jresult;
2774 }
2775
2776
2777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2778   void * jresult ;
2779   intp *result = 0 ;
2780
2781   {
2782     try {
2783       result = (intp *)new_intp();
2784     } catch (std::out_of_range& e) {
2785       {
2786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2787       };
2788     } catch (std::exception& e) {
2789       {
2790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2791       };
2792     } catch (Dali::DaliException e) {
2793       {
2794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2795       };
2796     } catch (...) {
2797       {
2798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2799       };
2800     }
2801   }
2802
2803   jresult = (void *)result;
2804   return jresult;
2805 }
2806
2807
2808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2809   intp *arg1 = (intp *) 0 ;
2810
2811   arg1 = (intp *)jarg1;
2812   {
2813     try {
2814       delete_intp(arg1);
2815     } catch (std::out_of_range& e) {
2816       {
2817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2818       };
2819     } catch (std::exception& e) {
2820       {
2821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2822       };
2823     } catch (Dali::DaliException e) {
2824       {
2825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2826       };
2827     } catch (...) {
2828       {
2829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2830       };
2831     }
2832   }
2833
2834 }
2835
2836
2837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2838   intp *arg1 = (intp *) 0 ;
2839   int arg2 ;
2840
2841   arg1 = (intp *)jarg1;
2842   arg2 = (int)jarg2;
2843   {
2844     try {
2845       intp_assign(arg1,arg2);
2846     } catch (std::out_of_range& e) {
2847       {
2848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2849       };
2850     } catch (std::exception& e) {
2851       {
2852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2853       };
2854     } catch (Dali::DaliException e) {
2855       {
2856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2857       };
2858     } catch (...) {
2859       {
2860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2861       };
2862     }
2863   }
2864
2865 }
2866
2867
2868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2869   int jresult ;
2870   intp *arg1 = (intp *) 0 ;
2871   int result;
2872
2873   arg1 = (intp *)jarg1;
2874   {
2875     try {
2876       result = (int)intp_value(arg1);
2877     } catch (std::out_of_range& e) {
2878       {
2879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2880       };
2881     } catch (std::exception& e) {
2882       {
2883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2884       };
2885     } catch (Dali::DaliException e) {
2886       {
2887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2888       };
2889     } catch (...) {
2890       {
2891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2892       };
2893     }
2894   }
2895
2896   jresult = result;
2897   return jresult;
2898 }
2899
2900
2901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2902   void * jresult ;
2903   intp *arg1 = (intp *) 0 ;
2904   int *result = 0 ;
2905
2906   arg1 = (intp *)jarg1;
2907   {
2908     try {
2909       result = (int *)intp_cast(arg1);
2910     } catch (std::out_of_range& e) {
2911       {
2912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2913       };
2914     } catch (std::exception& e) {
2915       {
2916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2917       };
2918     } catch (Dali::DaliException e) {
2919       {
2920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2921       };
2922     } catch (...) {
2923       {
2924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2925       };
2926     }
2927   }
2928
2929   jresult = (void *)result;
2930   return jresult;
2931 }
2932
2933
2934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2935   void * jresult ;
2936   int *arg1 = (int *) 0 ;
2937   intp *result = 0 ;
2938
2939   arg1 = (int *)jarg1;
2940   {
2941     try {
2942       result = (intp *)intp_frompointer(arg1);
2943     } catch (std::out_of_range& e) {
2944       {
2945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2946       };
2947     } catch (std::exception& e) {
2948       {
2949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2950       };
2951     } catch (Dali::DaliException e) {
2952       {
2953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2954       };
2955     } catch (...) {
2956       {
2957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2958       };
2959     }
2960   }
2961
2962   jresult = (void *)result;
2963   return jresult;
2964 }
2965
2966
2967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2968   void * jresult ;
2969   doublep *result = 0 ;
2970
2971   {
2972     try {
2973       result = (doublep *)new_doublep();
2974     } catch (std::out_of_range& e) {
2975       {
2976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (std::exception& e) {
2979       {
2980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2981       };
2982     } catch (Dali::DaliException e) {
2983       {
2984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2985       };
2986     } catch (...) {
2987       {
2988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2989       };
2990     }
2991   }
2992
2993   jresult = (void *)result;
2994   return jresult;
2995 }
2996
2997
2998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2999   doublep *arg1 = (doublep *) 0 ;
3000
3001   arg1 = (doublep *)jarg1;
3002   {
3003     try {
3004       delete_doublep(arg1);
3005     } catch (std::out_of_range& e) {
3006       {
3007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3008       };
3009     } catch (std::exception& e) {
3010       {
3011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3012       };
3013     } catch (Dali::DaliException e) {
3014       {
3015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3016       };
3017     } catch (...) {
3018       {
3019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3020       };
3021     }
3022   }
3023
3024 }
3025
3026
3027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3028   doublep *arg1 = (doublep *) 0 ;
3029   double arg2 ;
3030
3031   arg1 = (doublep *)jarg1;
3032   arg2 = (double)jarg2;
3033   {
3034     try {
3035       doublep_assign(arg1,arg2);
3036     } catch (std::out_of_range& e) {
3037       {
3038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3039       };
3040     } catch (std::exception& e) {
3041       {
3042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3043       };
3044     } catch (Dali::DaliException e) {
3045       {
3046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3047       };
3048     } catch (...) {
3049       {
3050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3051       };
3052     }
3053   }
3054
3055 }
3056
3057
3058 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3059   double jresult ;
3060   doublep *arg1 = (doublep *) 0 ;
3061   double result;
3062
3063   arg1 = (doublep *)jarg1;
3064   {
3065     try {
3066       result = (double)doublep_value(arg1);
3067     } catch (std::out_of_range& e) {
3068       {
3069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3070       };
3071     } catch (std::exception& e) {
3072       {
3073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3074       };
3075     } catch (Dali::DaliException e) {
3076       {
3077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3078       };
3079     } catch (...) {
3080       {
3081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3082       };
3083     }
3084   }
3085
3086   jresult = result;
3087   return jresult;
3088 }
3089
3090
3091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3092   void * jresult ;
3093   doublep *arg1 = (doublep *) 0 ;
3094   double *result = 0 ;
3095
3096   arg1 = (doublep *)jarg1;
3097   {
3098     try {
3099       result = (double *)doublep_cast(arg1);
3100     } catch (std::out_of_range& e) {
3101       {
3102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3103       };
3104     } catch (std::exception& e) {
3105       {
3106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3107       };
3108     } catch (Dali::DaliException e) {
3109       {
3110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3111       };
3112     } catch (...) {
3113       {
3114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3115       };
3116     }
3117   }
3118
3119   jresult = (void *)result;
3120   return jresult;
3121 }
3122
3123
3124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3125   void * jresult ;
3126   double *arg1 = (double *) 0 ;
3127   doublep *result = 0 ;
3128
3129   arg1 = (double *)jarg1;
3130   {
3131     try {
3132       result = (doublep *)doublep_frompointer(arg1);
3133     } catch (std::out_of_range& e) {
3134       {
3135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3136       };
3137     } catch (std::exception& e) {
3138       {
3139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3140       };
3141     } catch (Dali::DaliException e) {
3142       {
3143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3144       };
3145     } catch (...) {
3146       {
3147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3148       };
3149     }
3150   }
3151
3152   jresult = (void *)result;
3153   return jresult;
3154 }
3155
3156
3157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3158   void * jresult ;
3159   uintp *result = 0 ;
3160
3161   {
3162     try {
3163       result = (uintp *)new_uintp();
3164     } catch (std::out_of_range& e) {
3165       {
3166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3167       };
3168     } catch (std::exception& e) {
3169       {
3170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3171       };
3172     } catch (Dali::DaliException e) {
3173       {
3174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3175       };
3176     } catch (...) {
3177       {
3178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3179       };
3180     }
3181   }
3182
3183   jresult = (void *)result;
3184   return jresult;
3185 }
3186
3187
3188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3189   uintp *arg1 = (uintp *) 0 ;
3190
3191   arg1 = (uintp *)jarg1;
3192   {
3193     try {
3194       delete_uintp(arg1);
3195     } catch (std::out_of_range& e) {
3196       {
3197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3198       };
3199     } catch (std::exception& e) {
3200       {
3201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3202       };
3203     } catch (Dali::DaliException e) {
3204       {
3205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3206       };
3207     } catch (...) {
3208       {
3209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3210       };
3211     }
3212   }
3213
3214 }
3215
3216
3217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3218   uintp *arg1 = (uintp *) 0 ;
3219   unsigned int arg2 ;
3220
3221   arg1 = (uintp *)jarg1;
3222   arg2 = (unsigned int)jarg2;
3223   {
3224     try {
3225       uintp_assign(arg1,arg2);
3226     } catch (std::out_of_range& e) {
3227       {
3228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3229       };
3230     } catch (std::exception& e) {
3231       {
3232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3233       };
3234     } catch (Dali::DaliException e) {
3235       {
3236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3237       };
3238     } catch (...) {
3239       {
3240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3241       };
3242     }
3243   }
3244
3245 }
3246
3247
3248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3249   unsigned int jresult ;
3250   uintp *arg1 = (uintp *) 0 ;
3251   unsigned int result;
3252
3253   arg1 = (uintp *)jarg1;
3254   {
3255     try {
3256       result = (unsigned int)uintp_value(arg1);
3257     } catch (std::out_of_range& e) {
3258       {
3259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3260       };
3261     } catch (std::exception& e) {
3262       {
3263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3264       };
3265     } catch (Dali::DaliException e) {
3266       {
3267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3268       };
3269     } catch (...) {
3270       {
3271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3272       };
3273     }
3274   }
3275
3276   jresult = result;
3277   return jresult;
3278 }
3279
3280
3281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3282   void * jresult ;
3283   uintp *arg1 = (uintp *) 0 ;
3284   unsigned int *result = 0 ;
3285
3286   arg1 = (uintp *)jarg1;
3287   {
3288     try {
3289       result = (unsigned int *)uintp_cast(arg1);
3290     } catch (std::out_of_range& e) {
3291       {
3292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3293       };
3294     } catch (std::exception& e) {
3295       {
3296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3297       };
3298     } catch (Dali::DaliException e) {
3299       {
3300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3301       };
3302     } catch (...) {
3303       {
3304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3305       };
3306     }
3307   }
3308
3309   jresult = (void *)result;
3310   return jresult;
3311 }
3312
3313
3314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3315   void * jresult ;
3316   unsigned int *arg1 = (unsigned int *) 0 ;
3317   uintp *result = 0 ;
3318
3319   arg1 = (unsigned int *)jarg1;
3320   {
3321     try {
3322       result = (uintp *)uintp_frompointer(arg1);
3323     } catch (std::out_of_range& e) {
3324       {
3325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3326       };
3327     } catch (std::exception& e) {
3328       {
3329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3330       };
3331     } catch (Dali::DaliException e) {
3332       {
3333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3334       };
3335     } catch (...) {
3336       {
3337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3338       };
3339     }
3340   }
3341
3342   jresult = (void *)result;
3343   return jresult;
3344 }
3345
3346
3347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3348   void * jresult ;
3349   ushortp *result = 0 ;
3350
3351   {
3352     try {
3353       result = (ushortp *)new_ushortp();
3354     } catch (std::out_of_range& e) {
3355       {
3356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3357       };
3358     } catch (std::exception& e) {
3359       {
3360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3361       };
3362     } catch (Dali::DaliException e) {
3363       {
3364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3365       };
3366     } catch (...) {
3367       {
3368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3369       };
3370     }
3371   }
3372
3373   jresult = (void *)result;
3374   return jresult;
3375 }
3376
3377
3378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3379   ushortp *arg1 = (ushortp *) 0 ;
3380
3381   arg1 = (ushortp *)jarg1;
3382   {
3383     try {
3384       delete_ushortp(arg1);
3385     } catch (std::out_of_range& e) {
3386       {
3387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3388       };
3389     } catch (std::exception& e) {
3390       {
3391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3392       };
3393     } catch (Dali::DaliException e) {
3394       {
3395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3396       };
3397     } catch (...) {
3398       {
3399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3400       };
3401     }
3402   }
3403
3404 }
3405
3406
3407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3408   ushortp *arg1 = (ushortp *) 0 ;
3409   unsigned short arg2 ;
3410
3411   arg1 = (ushortp *)jarg1;
3412   arg2 = (unsigned short)jarg2;
3413   {
3414     try {
3415       ushortp_assign(arg1,arg2);
3416     } catch (std::out_of_range& e) {
3417       {
3418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3419       };
3420     } catch (std::exception& e) {
3421       {
3422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (Dali::DaliException e) {
3425       {
3426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434
3435 }
3436
3437
3438 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3439   unsigned short jresult ;
3440   ushortp *arg1 = (ushortp *) 0 ;
3441   unsigned short result;
3442
3443   arg1 = (ushortp *)jarg1;
3444   {
3445     try {
3446       result = (unsigned short)ushortp_value(arg1);
3447     } catch (std::out_of_range& e) {
3448       {
3449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3450       };
3451     } catch (std::exception& e) {
3452       {
3453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3454       };
3455     } catch (Dali::DaliException e) {
3456       {
3457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3458       };
3459     } catch (...) {
3460       {
3461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3462       };
3463     }
3464   }
3465
3466   jresult = result;
3467   return jresult;
3468 }
3469
3470
3471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3472   void * jresult ;
3473   ushortp *arg1 = (ushortp *) 0 ;
3474   unsigned short *result = 0 ;
3475
3476   arg1 = (ushortp *)jarg1;
3477   {
3478     try {
3479       result = (unsigned short *)ushortp_cast(arg1);
3480     } catch (std::out_of_range& e) {
3481       {
3482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3483       };
3484     } catch (std::exception& e) {
3485       {
3486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3487       };
3488     } catch (Dali::DaliException e) {
3489       {
3490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3491       };
3492     } catch (...) {
3493       {
3494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3495       };
3496     }
3497   }
3498
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3505   void * jresult ;
3506   unsigned short *arg1 = (unsigned short *) 0 ;
3507   ushortp *result = 0 ;
3508
3509   arg1 = (unsigned short *)jarg1;
3510   {
3511     try {
3512       result = (ushortp *)ushortp_frompointer(arg1);
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (Dali::DaliException e) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3524       };
3525     } catch (...) {
3526       {
3527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3528       };
3529     }
3530   }
3531
3532   jresult = (void *)result;
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3538   unsigned int jresult ;
3539   int arg1 ;
3540   unsigned int result;
3541
3542   arg1 = (int)jarg1;
3543   {
3544     try {
3545       result = (unsigned int)int_to_uint(arg1);
3546     } catch (std::out_of_range& e) {
3547       {
3548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3549       };
3550     } catch (std::exception& e) {
3551       {
3552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3553       };
3554     } catch (Dali::DaliException e) {
3555       {
3556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3557       };
3558     } catch (...) {
3559       {
3560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3561       };
3562     }
3563   }
3564
3565   jresult = result;
3566   return jresult;
3567 }
3568
3569
3570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3571   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3572
3573   arg1 = (Dali::RefObject *)jarg1;
3574   {
3575     try {
3576       (arg1)->Reference();
3577     } catch (std::out_of_range& e) {
3578       {
3579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3580       };
3581     } catch (std::exception& e) {
3582       {
3583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3584       };
3585     } catch (Dali::DaliException e) {
3586       {
3587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3588       };
3589     } catch (...) {
3590       {
3591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3592       };
3593     }
3594   }
3595
3596 }
3597
3598
3599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3600   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3601
3602   arg1 = (Dali::RefObject *)jarg1;
3603   {
3604     try {
3605       (arg1)->Unreference();
3606     } catch (std::out_of_range& e) {
3607       {
3608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3609       };
3610     } catch (std::exception& e) {
3611       {
3612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3613       };
3614     } catch (Dali::DaliException e) {
3615       {
3616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3617       };
3618     } catch (...) {
3619       {
3620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3621       };
3622     }
3623   }
3624
3625 }
3626
3627
3628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3629   int jresult ;
3630   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3631   int result;
3632
3633   arg1 = (Dali::RefObject *)jarg1;
3634   {
3635     try {
3636       result = (int)(arg1)->ReferenceCount();
3637     } catch (std::out_of_range& e) {
3638       {
3639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3640       };
3641     } catch (std::exception& e) {
3642       {
3643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3644       };
3645     } catch (Dali::DaliException e) {
3646       {
3647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3648       };
3649     } catch (...) {
3650       {
3651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3652       };
3653     }
3654   }
3655
3656   jresult = result;
3657   return jresult;
3658 }
3659
3660
3661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3662   void * jresult ;
3663   Dali::Any *result = 0 ;
3664
3665   {
3666     try {
3667       result = (Dali::Any *)new Dali::Any();
3668     } catch (std::out_of_range& e) {
3669       {
3670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3671       };
3672     } catch (std::exception& e) {
3673       {
3674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3675       };
3676     } catch (Dali::DaliException e) {
3677       {
3678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3679       };
3680     } catch (...) {
3681       {
3682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3683       };
3684     }
3685   }
3686
3687   jresult = (void *)result;
3688   return jresult;
3689 }
3690
3691
3692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3693   Dali::Any *arg1 = (Dali::Any *) 0 ;
3694
3695   arg1 = (Dali::Any *)jarg1;
3696   {
3697     try {
3698       delete arg1;
3699     } catch (std::out_of_range& e) {
3700       {
3701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3702       };
3703     } catch (std::exception& e) {
3704       {
3705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3706       };
3707     } catch (Dali::DaliException e) {
3708       {
3709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3710       };
3711     } catch (...) {
3712       {
3713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3714       };
3715     }
3716   }
3717
3718 }
3719
3720
3721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3722   char *arg1 = (char *) 0 ;
3723
3724   arg1 = (char *)jarg1;
3725   {
3726     try {
3727       Dali::Any::AssertAlways((char const *)arg1);
3728     } catch (std::out_of_range& e) {
3729       {
3730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3731       };
3732     } catch (std::exception& e) {
3733       {
3734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3735       };
3736     } catch (Dali::DaliException e) {
3737       {
3738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3739       };
3740     } catch (...) {
3741       {
3742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3743       };
3744     }
3745   }
3746
3747 }
3748
3749
3750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3751   void * jresult ;
3752   Dali::Any *arg1 = 0 ;
3753   Dali::Any *result = 0 ;
3754
3755   arg1 = (Dali::Any *)jarg1;
3756   if (!arg1) {
3757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3758     return 0;
3759   }
3760   {
3761     try {
3762       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3763     } catch (std::out_of_range& e) {
3764       {
3765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3766       };
3767     } catch (std::exception& e) {
3768       {
3769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3770       };
3771     } catch (Dali::DaliException e) {
3772       {
3773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3774       };
3775     } catch (...) {
3776       {
3777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3778       };
3779     }
3780   }
3781
3782   jresult = (void *)result;
3783   return jresult;
3784 }
3785
3786
3787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3788   void * jresult ;
3789   Dali::Any *arg1 = (Dali::Any *) 0 ;
3790   Dali::Any *arg2 = 0 ;
3791   Dali::Any *result = 0 ;
3792
3793   arg1 = (Dali::Any *)jarg1;
3794   arg2 = (Dali::Any *)jarg2;
3795   if (!arg2) {
3796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3797     return 0;
3798   }
3799   {
3800     try {
3801       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3802     } catch (std::out_of_range& e) {
3803       {
3804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3805       };
3806     } catch (std::exception& e) {
3807       {
3808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3809       };
3810     } catch (Dali::DaliException e) {
3811       {
3812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3813       };
3814     } catch (...) {
3815       {
3816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3817       };
3818     }
3819   }
3820
3821   jresult = (void *)result;
3822   return jresult;
3823 }
3824
3825
3826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3827   void * jresult ;
3828   Dali::Any *arg1 = (Dali::Any *) 0 ;
3829   std::type_info *result = 0 ;
3830
3831   arg1 = (Dali::Any *)jarg1;
3832   {
3833     try {
3834       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3835     } catch (std::out_of_range& e) {
3836       {
3837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3838       };
3839     } catch (std::exception& e) {
3840       {
3841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3842       };
3843     } catch (Dali::DaliException e) {
3844       {
3845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3846       };
3847     } catch (...) {
3848       {
3849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3850       };
3851     }
3852   }
3853
3854   jresult = (void *)result;
3855   return jresult;
3856 }
3857
3858
3859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3860   unsigned int jresult ;
3861   Dali::Any *arg1 = (Dali::Any *) 0 ;
3862   bool result;
3863
3864   arg1 = (Dali::Any *)jarg1;
3865   {
3866     try {
3867       result = (bool)((Dali::Any const *)arg1)->Empty();
3868     } catch (std::out_of_range& e) {
3869       {
3870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3871       };
3872     } catch (std::exception& e) {
3873       {
3874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3875       };
3876     } catch (Dali::DaliException e) {
3877       {
3878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3879       };
3880     } catch (...) {
3881       {
3882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3883       };
3884     }
3885   }
3886
3887   jresult = result;
3888   return jresult;
3889 }
3890
3891
3892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3893   void * jresult ;
3894   std::type_info *arg1 = 0 ;
3895   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3896   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3897   Dali::Any::AnyContainerBase *result = 0 ;
3898
3899   arg1 = (std::type_info *)jarg1;
3900   if (!arg1) {
3901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3902     return 0;
3903   }
3904   arg2 = (Dali::Any::CloneFunc)jarg2;
3905   arg3 = (Dali::Any::DeleteFunc)jarg3;
3906   {
3907     try {
3908       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3909     } catch (std::out_of_range& e) {
3910       {
3911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3912       };
3913     } catch (std::exception& e) {
3914       {
3915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3916       };
3917     } catch (Dali::DaliException e) {
3918       {
3919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3920       };
3921     } catch (...) {
3922       {
3923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3924       };
3925     }
3926   }
3927
3928   jresult = (void *)result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3934   void * jresult ;
3935   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3936   std::type_info *result = 0 ;
3937
3938   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3939   {
3940     try {
3941       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3942     } catch (std::out_of_range& e) {
3943       {
3944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3945       };
3946     } catch (std::exception& e) {
3947       {
3948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3949       };
3950     } catch (Dali::DaliException e) {
3951       {
3952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3953       };
3954     } catch (...) {
3955       {
3956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3957       };
3958     }
3959   }
3960
3961   jresult = (void *)result;
3962   return jresult;
3963 }
3964
3965
3966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3967   void * jresult ;
3968   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3969   ::std::type_info *result = 0 ;
3970
3971   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3972   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3973   jresult = (void *)result;
3974   return jresult;
3975 }
3976
3977
3978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3979   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3980   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3981
3982   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3983   arg2 = (Dali::Any::CloneFunc)jarg2;
3984   if (arg1) (arg1)->mCloneFunc = arg2;
3985 }
3986
3987
3988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3989   void * jresult ;
3990   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3991   Dali::Any::CloneFunc result;
3992
3993   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3994   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3995   jresult = (void *)result;
3996   return jresult;
3997 }
3998
3999
4000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4001   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4002   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4003
4004   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4005   arg2 = (Dali::Any::DeleteFunc)jarg2;
4006   if (arg1) (arg1)->mDeleteFunc = arg2;
4007 }
4008
4009
4010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4011   void * jresult ;
4012   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4013   Dali::Any::DeleteFunc result;
4014
4015   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4016   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4017   jresult = (void *)result;
4018   return jresult;
4019 }
4020
4021
4022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4023   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4024
4025   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4026   {
4027     try {
4028       delete arg1;
4029     } catch (std::out_of_range& e) {
4030       {
4031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4032       };
4033     } catch (std::exception& e) {
4034       {
4035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4036       };
4037     } catch (Dali::DaliException e) {
4038       {
4039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4040       };
4041     } catch (...) {
4042       {
4043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4044       };
4045     }
4046   }
4047
4048 }
4049
4050
4051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4052   Dali::Any *arg1 = (Dali::Any *) 0 ;
4053   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4054
4055   arg1 = (Dali::Any *)jarg1;
4056   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4057   if (arg1) (arg1)->mContainer = arg2;
4058 }
4059
4060
4061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4062   void * jresult ;
4063   Dali::Any *arg1 = (Dali::Any *) 0 ;
4064   Dali::Any::AnyContainerBase *result = 0 ;
4065
4066   arg1 = (Dali::Any *)jarg1;
4067   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4068   jresult = (void *)result;
4069   return jresult;
4070 }
4071
4072
4073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4074   char *arg1 = (char *) 0 ;
4075   char *arg2 = (char *) 0 ;
4076
4077   arg1 = (char *)jarg1;
4078   arg2 = (char *)jarg2;
4079   {
4080     try {
4081       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4082     } catch (std::out_of_range& e) {
4083       {
4084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4085       };
4086     } catch (std::exception& e) {
4087       {
4088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4089       };
4090     } catch (Dali::DaliException e) {
4091       {
4092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4093       };
4094     } catch (...) {
4095       {
4096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4097       };
4098     }
4099   }
4100
4101 }
4102
4103
4104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4105   void * jresult ;
4106   char *arg1 = (char *) 0 ;
4107   char *arg2 = (char *) 0 ;
4108   Dali::DaliException *result = 0 ;
4109
4110   arg1 = (char *)jarg1;
4111   arg2 = (char *)jarg2;
4112   {
4113     try {
4114       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4115     } catch (std::out_of_range& e) {
4116       {
4117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4118       };
4119     } catch (std::exception& e) {
4120       {
4121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4122       };
4123     } catch (Dali::DaliException e) {
4124       {
4125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4126       };
4127     } catch (...) {
4128       {
4129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4130       };
4131     }
4132   }
4133
4134   jresult = (void *)result;
4135   return jresult;
4136 }
4137
4138
4139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4140   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4141   std::string arg2 = std::string(jarg2);
4142
4143   arg1 = (Dali::DaliException *)jarg1;
4144   {
4145     if (!arg2.empty()) {
4146       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4147     } else {
4148       arg1->location = 0;
4149     }
4150   }
4151 }
4152
4153 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4154   char * jresult ;
4155   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4156   char *result = 0 ;
4157
4158   arg1 = (Dali::DaliException *)jarg1;
4159   result = (char *) ((arg1)->location);
4160   jresult = SWIG_csharp_string_callback((const char *)result);
4161   return jresult;
4162 }
4163
4164
4165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4166   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4167   std::string arg2 = std::string(jarg2);
4168
4169   arg1 = (Dali::DaliException *)jarg1;
4170   {
4171     if (!arg2.empty()) {
4172       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4173     } else {
4174       arg1->condition = 0;
4175     }
4176   }
4177 }
4178
4179
4180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4181   char * jresult ;
4182   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4183   char *result = 0 ;
4184
4185   arg1 = (Dali::DaliException *)jarg1;
4186   result = (char *) ((arg1)->condition);
4187   jresult = SWIG_csharp_string_callback((const char *)result);
4188   return jresult;
4189 }
4190
4191
4192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4193   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4194
4195   arg1 = (Dali::DaliException *)jarg1;
4196   {
4197     try {
4198       delete arg1;
4199     } catch (std::out_of_range& e) {
4200       {
4201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4202       };
4203     } catch (std::exception& e) {
4204       {
4205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4206       };
4207     } catch (Dali::DaliException e) {
4208       {
4209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4210       };
4211     } catch (...) {
4212       {
4213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4214       };
4215     }
4216   }
4217
4218 }
4219
4220
4221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4222   void * jresult ;
4223   Dali::Vector2 *result = 0 ;
4224
4225   {
4226     try {
4227       result = (Dali::Vector2 *)new Dali::Vector2();
4228     } catch (std::out_of_range& e) {
4229       {
4230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4231       };
4232     } catch (std::exception& e) {
4233       {
4234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4235       };
4236     } catch (Dali::DaliException e) {
4237       {
4238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4239       };
4240     } catch (...) {
4241       {
4242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4243       };
4244     }
4245   }
4246
4247   jresult = (void *)result;
4248   return jresult;
4249 }
4250
4251
4252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4253   void * jresult ;
4254   float arg1 ;
4255   float arg2 ;
4256   Dali::Vector2 *result = 0 ;
4257
4258   arg1 = (float)jarg1;
4259   arg2 = (float)jarg2;
4260   {
4261     try {
4262       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4263     } catch (std::out_of_range& e) {
4264       {
4265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4266       };
4267     } catch (std::exception& e) {
4268       {
4269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4270       };
4271     } catch (Dali::DaliException e) {
4272       {
4273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4274       };
4275     } catch (...) {
4276       {
4277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4278       };
4279     }
4280   }
4281
4282   jresult = (void *)result;
4283   return jresult;
4284 }
4285
4286
4287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4288   void * jresult ;
4289   float *arg1 = (float *) 0 ;
4290   Dali::Vector2 *result = 0 ;
4291
4292   arg1 = jarg1;
4293   {
4294     try {
4295       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4296     } catch (std::out_of_range& e) {
4297       {
4298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4299       };
4300     } catch (std::exception& e) {
4301       {
4302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4303       };
4304     } catch (Dali::DaliException e) {
4305       {
4306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4307       };
4308     } catch (...) {
4309       {
4310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4311       };
4312     }
4313   }
4314
4315   jresult = (void *)result;
4316
4317
4318   return jresult;
4319 }
4320
4321
4322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4323   void * jresult ;
4324   Dali::Vector3 *arg1 = 0 ;
4325   Dali::Vector2 *result = 0 ;
4326
4327   arg1 = (Dali::Vector3 *)jarg1;
4328   if (!arg1) {
4329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4330     return 0;
4331   }
4332   {
4333     try {
4334       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4335     } catch (std::out_of_range& e) {
4336       {
4337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4338       };
4339     } catch (std::exception& e) {
4340       {
4341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4342       };
4343     } catch (Dali::DaliException e) {
4344       {
4345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4346       };
4347     } catch (...) {
4348       {
4349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4350       };
4351     }
4352   }
4353
4354   jresult = (void *)result;
4355   return jresult;
4356 }
4357
4358
4359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4360   void * jresult ;
4361   Dali::Vector4 *arg1 = 0 ;
4362   Dali::Vector2 *result = 0 ;
4363
4364   arg1 = (Dali::Vector4 *)jarg1;
4365   if (!arg1) {
4366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4367     return 0;
4368   }
4369   {
4370     try {
4371       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4372     } catch (std::out_of_range& e) {
4373       {
4374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4375       };
4376     } catch (std::exception& e) {
4377       {
4378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4379       };
4380     } catch (Dali::DaliException e) {
4381       {
4382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4383       };
4384     } catch (...) {
4385       {
4386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4387       };
4388     }
4389   }
4390
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4427   void * jresult ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4431   jresult = (void *)result;
4432   return jresult;
4433 }
4434
4435
4436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4437   void * jresult ;
4438   Dali::Vector2 *result = 0 ;
4439
4440   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4441   jresult = (void *)result;
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4447   void * jresult ;
4448   Dali::Vector2 *result = 0 ;
4449
4450   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4451   jresult = (void *)result;
4452   return jresult;
4453 }
4454
4455
4456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4457   void * jresult ;
4458   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4459   float *arg2 = (float *) 0 ;
4460   Dali::Vector2 *result = 0 ;
4461
4462   arg1 = (Dali::Vector2 *)jarg1;
4463   arg2 = jarg2;
4464   {
4465     try {
4466       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4467     } catch (std::out_of_range& e) {
4468       {
4469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4470       };
4471     } catch (std::exception& e) {
4472       {
4473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4474       };
4475     } catch (Dali::DaliException e) {
4476       {
4477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4478       };
4479     } catch (...) {
4480       {
4481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4482       };
4483     }
4484   }
4485
4486   jresult = (void *)result;
4487
4488
4489   return jresult;
4490 }
4491
4492
4493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4494   void * jresult ;
4495   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4496   Dali::Vector3 *arg2 = 0 ;
4497   Dali::Vector2 *result = 0 ;
4498
4499   arg1 = (Dali::Vector2 *)jarg1;
4500   arg2 = (Dali::Vector3 *)jarg2;
4501   if (!arg2) {
4502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4503     return 0;
4504   }
4505   {
4506     try {
4507       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4508     } catch (std::out_of_range& e) {
4509       {
4510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4511       };
4512     } catch (std::exception& e) {
4513       {
4514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4515       };
4516     } catch (Dali::DaliException e) {
4517       {
4518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4519       };
4520     } catch (...) {
4521       {
4522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4523       };
4524     }
4525   }
4526
4527   jresult = (void *)result;
4528   return jresult;
4529 }
4530
4531
4532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4533   void * jresult ;
4534   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4535   Dali::Vector4 *arg2 = 0 ;
4536   Dali::Vector2 *result = 0 ;
4537
4538   arg1 = (Dali::Vector2 *)jarg1;
4539   arg2 = (Dali::Vector4 *)jarg2;
4540   if (!arg2) {
4541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4542     return 0;
4543   }
4544   {
4545     try {
4546       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4547     } catch (std::out_of_range& e) {
4548       {
4549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4550       };
4551     } catch (std::exception& e) {
4552       {
4553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (Dali::DaliException e) {
4556       {
4557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4558       };
4559     } catch (...) {
4560       {
4561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4562       };
4563     }
4564   }
4565
4566   jresult = (void *)result;
4567   return jresult;
4568 }
4569
4570
4571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4572   void * jresult ;
4573   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4574   Dali::Vector2 *arg2 = 0 ;
4575   Dali::Vector2 result;
4576
4577   arg1 = (Dali::Vector2 *)jarg1;
4578   arg2 = (Dali::Vector2 *)jarg2;
4579   if (!arg2) {
4580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4581     return 0;
4582   }
4583   {
4584     try {
4585       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4586     } catch (std::out_of_range& e) {
4587       {
4588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4589       };
4590     } catch (std::exception& e) {
4591       {
4592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4593       };
4594     } catch (Dali::DaliException e) {
4595       {
4596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4597       };
4598     } catch (...) {
4599       {
4600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4601       };
4602     }
4603   }
4604
4605   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4606   return jresult;
4607 }
4608
4609
4610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4611   void * jresult ;
4612   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4613   Dali::Vector2 *arg2 = 0 ;
4614   Dali::Vector2 *result = 0 ;
4615
4616   arg1 = (Dali::Vector2 *)jarg1;
4617   arg2 = (Dali::Vector2 *)jarg2;
4618   if (!arg2) {
4619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4620     return 0;
4621   }
4622   {
4623     try {
4624       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4625     } catch (std::out_of_range& e) {
4626       {
4627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4628       };
4629     } catch (std::exception& e) {
4630       {
4631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4632       };
4633     } catch (Dali::DaliException e) {
4634       {
4635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4636       };
4637     } catch (...) {
4638       {
4639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4640       };
4641     }
4642   }
4643
4644   jresult = (void *)result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4650   void * jresult ;
4651   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4652   Dali::Vector2 *arg2 = 0 ;
4653   Dali::Vector2 result;
4654
4655   arg1 = (Dali::Vector2 *)jarg1;
4656   arg2 = (Dali::Vector2 *)jarg2;
4657   if (!arg2) {
4658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4659     return 0;
4660   }
4661   {
4662     try {
4663       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4664     } catch (std::out_of_range& e) {
4665       {
4666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4667       };
4668     } catch (std::exception& e) {
4669       {
4670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4671       };
4672     } catch (Dali::DaliException e) {
4673       {
4674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4675       };
4676     } catch (...) {
4677       {
4678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4679       };
4680     }
4681   }
4682
4683   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4684   return jresult;
4685 }
4686
4687
4688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4689   void * jresult ;
4690   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4691   Dali::Vector2 *arg2 = 0 ;
4692   Dali::Vector2 *result = 0 ;
4693
4694   arg1 = (Dali::Vector2 *)jarg1;
4695   arg2 = (Dali::Vector2 *)jarg2;
4696   if (!arg2) {
4697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4698     return 0;
4699   }
4700   {
4701     try {
4702       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4703     } catch (std::out_of_range& e) {
4704       {
4705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4706       };
4707     } catch (std::exception& e) {
4708       {
4709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4710       };
4711     } catch (Dali::DaliException e) {
4712       {
4713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4714       };
4715     } catch (...) {
4716       {
4717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4718       };
4719     }
4720   }
4721
4722   jresult = (void *)result;
4723   return jresult;
4724 }
4725
4726
4727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4728   void * jresult ;
4729   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4730   Dali::Vector2 *arg2 = 0 ;
4731   Dali::Vector2 result;
4732
4733   arg1 = (Dali::Vector2 *)jarg1;
4734   arg2 = (Dali::Vector2 *)jarg2;
4735   if (!arg2) {
4736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4737     return 0;
4738   }
4739   {
4740     try {
4741       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4742     } catch (std::out_of_range& e) {
4743       {
4744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4745       };
4746     } catch (std::exception& e) {
4747       {
4748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4749       };
4750     } catch (Dali::DaliException e) {
4751       {
4752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4753       };
4754     } catch (...) {
4755       {
4756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4757       };
4758     }
4759   }
4760
4761   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4762   return jresult;
4763 }
4764
4765
4766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4767   void * jresult ;
4768   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4769   float arg2 ;
4770   Dali::Vector2 result;
4771
4772   arg1 = (Dali::Vector2 *)jarg1;
4773   arg2 = (float)jarg2;
4774   {
4775     try {
4776       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4777     } catch (std::out_of_range& e) {
4778       {
4779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4780       };
4781     } catch (std::exception& e) {
4782       {
4783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4784       };
4785     } catch (Dali::DaliException e) {
4786       {
4787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4788       };
4789     } catch (...) {
4790       {
4791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4792       };
4793     }
4794   }
4795
4796   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4797   return jresult;
4798 }
4799
4800
4801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4802   void * jresult ;
4803   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4804   Dali::Vector2 *arg2 = 0 ;
4805   Dali::Vector2 *result = 0 ;
4806
4807   arg1 = (Dali::Vector2 *)jarg1;
4808   arg2 = (Dali::Vector2 *)jarg2;
4809   if (!arg2) {
4810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4811     return 0;
4812   }
4813   {
4814     try {
4815       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4816     } catch (std::out_of_range& e) {
4817       {
4818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4819       };
4820     } catch (std::exception& e) {
4821       {
4822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4823       };
4824     } catch (Dali::DaliException e) {
4825       {
4826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4827       };
4828     } catch (...) {
4829       {
4830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4831       };
4832     }
4833   }
4834
4835   jresult = (void *)result;
4836   return jresult;
4837 }
4838
4839
4840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4841   void * jresult ;
4842   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4843   float arg2 ;
4844   Dali::Vector2 *result = 0 ;
4845
4846   arg1 = (Dali::Vector2 *)jarg1;
4847   arg2 = (float)jarg2;
4848   {
4849     try {
4850       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4851     } catch (std::out_of_range& e) {
4852       {
4853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4854       };
4855     } catch (std::exception& e) {
4856       {
4857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4858       };
4859     } catch (Dali::DaliException e) {
4860       {
4861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4862       };
4863     } catch (...) {
4864       {
4865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4866       };
4867     }
4868   }
4869
4870   jresult = (void *)result;
4871   return jresult;
4872 }
4873
4874
4875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4876   void * jresult ;
4877   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4878   Dali::Vector2 *arg2 = 0 ;
4879   Dali::Vector2 result;
4880
4881   arg1 = (Dali::Vector2 *)jarg1;
4882   arg2 = (Dali::Vector2 *)jarg2;
4883   if (!arg2) {
4884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4885     return 0;
4886   }
4887   {
4888     try {
4889       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4890     } catch (std::out_of_range& e) {
4891       {
4892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4893       };
4894     } catch (std::exception& e) {
4895       {
4896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4897       };
4898     } catch (Dali::DaliException e) {
4899       {
4900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4901       };
4902     } catch (...) {
4903       {
4904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4905       };
4906     }
4907   }
4908
4909   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4910   return jresult;
4911 }
4912
4913
4914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4915   void * jresult ;
4916   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4917   float arg2 ;
4918   Dali::Vector2 result;
4919
4920   arg1 = (Dali::Vector2 *)jarg1;
4921   arg2 = (float)jarg2;
4922   {
4923     try {
4924       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4925     } catch (std::out_of_range& e) {
4926       {
4927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4928       };
4929     } catch (std::exception& e) {
4930       {
4931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4932       };
4933     } catch (Dali::DaliException e) {
4934       {
4935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4936       };
4937     } catch (...) {
4938       {
4939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4940       };
4941     }
4942   }
4943
4944   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4945   return jresult;
4946 }
4947
4948
4949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4950   void * jresult ;
4951   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4952   Dali::Vector2 *arg2 = 0 ;
4953   Dali::Vector2 *result = 0 ;
4954
4955   arg1 = (Dali::Vector2 *)jarg1;
4956   arg2 = (Dali::Vector2 *)jarg2;
4957   if (!arg2) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4959     return 0;
4960   }
4961   {
4962     try {
4963       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4964     } catch (std::out_of_range& e) {
4965       {
4966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4967       };
4968     } catch (std::exception& e) {
4969       {
4970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4971       };
4972     } catch (Dali::DaliException e) {
4973       {
4974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4975       };
4976     } catch (...) {
4977       {
4978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4979       };
4980     }
4981   }
4982
4983   jresult = (void *)result;
4984   return jresult;
4985 }
4986
4987
4988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4989   void * jresult ;
4990   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4991   float arg2 ;
4992   Dali::Vector2 *result = 0 ;
4993
4994   arg1 = (Dali::Vector2 *)jarg1;
4995   arg2 = (float)jarg2;
4996   {
4997     try {
4998       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4999     } catch (std::out_of_range& e) {
5000       {
5001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5002       };
5003     } catch (std::exception& e) {
5004       {
5005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5006       };
5007     } catch (Dali::DaliException e) {
5008       {
5009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5010       };
5011     } catch (...) {
5012       {
5013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5014       };
5015     }
5016   }
5017
5018   jresult = (void *)result;
5019   return jresult;
5020 }
5021
5022
5023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5024   void * jresult ;
5025   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5026   Dali::Vector2 result;
5027
5028   arg1 = (Dali::Vector2 *)jarg1;
5029   {
5030     try {
5031       result = ((Dali::Vector2 const *)arg1)->operator -();
5032     } catch (std::out_of_range& e) {
5033       {
5034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5035       };
5036     } catch (std::exception& e) {
5037       {
5038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5039       };
5040     } catch (Dali::DaliException e) {
5041       {
5042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5043       };
5044     } catch (...) {
5045       {
5046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5047       };
5048     }
5049   }
5050
5051   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5052   return jresult;
5053 }
5054
5055
5056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5057   unsigned int jresult ;
5058   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5059   Dali::Vector2 *arg2 = 0 ;
5060   bool result;
5061
5062   arg1 = (Dali::Vector2 *)jarg1;
5063   arg2 = (Dali::Vector2 *)jarg2;
5064   if (!arg2) {
5065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5066     return 0;
5067   }
5068   {
5069     try {
5070       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (Dali::DaliException e) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5082       };
5083     } catch (...) {
5084       {
5085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5086       };
5087     }
5088   }
5089
5090   jresult = result;
5091   return jresult;
5092 }
5093
5094
5095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5096   unsigned int jresult ;
5097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5098   Dali::Vector2 *arg2 = 0 ;
5099   bool result;
5100
5101   arg1 = (Dali::Vector2 *)jarg1;
5102   arg2 = (Dali::Vector2 *)jarg2;
5103   if (!arg2) {
5104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5105     return 0;
5106   }
5107   {
5108     try {
5109       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5110     } catch (std::out_of_range& e) {
5111       {
5112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5113       };
5114     } catch (std::exception& e) {
5115       {
5116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5117       };
5118     } catch (Dali::DaliException e) {
5119       {
5120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5121       };
5122     } catch (...) {
5123       {
5124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5125       };
5126     }
5127   }
5128
5129   jresult = result;
5130   return jresult;
5131 }
5132
5133
5134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5135   float jresult ;
5136   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5137   unsigned int arg2 ;
5138   float *result = 0 ;
5139
5140   arg1 = (Dali::Vector2 *)jarg1;
5141   arg2 = (unsigned int)jarg2;
5142   {
5143     try {
5144       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5145     } catch (std::out_of_range& e) {
5146       {
5147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5148       };
5149     } catch (std::exception& e) {
5150       {
5151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5152       };
5153     } catch (Dali::DaliException e) {
5154       {
5155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5156       };
5157     } catch (...) {
5158       {
5159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5160       };
5161     }
5162   }
5163
5164   jresult = *result;
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5170   float jresult ;
5171   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5172   float result;
5173
5174   arg1 = (Dali::Vector2 *)jarg1;
5175   {
5176     try {
5177       result = (float)((Dali::Vector2 const *)arg1)->Length();
5178     } catch (std::out_of_range& e) {
5179       {
5180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5181       };
5182     } catch (std::exception& e) {
5183       {
5184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5185       };
5186     } catch (Dali::DaliException e) {
5187       {
5188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5189       };
5190     } catch (...) {
5191       {
5192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5193       };
5194     }
5195   }
5196
5197   jresult = result;
5198   return jresult;
5199 }
5200
5201
5202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5203   float jresult ;
5204   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5205   float result;
5206
5207   arg1 = (Dali::Vector2 *)jarg1;
5208   {
5209     try {
5210       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5211     } catch (std::out_of_range& e) {
5212       {
5213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5214       };
5215     } catch (std::exception& e) {
5216       {
5217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5218       };
5219     } catch (Dali::DaliException e) {
5220       {
5221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5222       };
5223     } catch (...) {
5224       {
5225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5226       };
5227     }
5228   }
5229
5230   jresult = result;
5231   return jresult;
5232 }
5233
5234
5235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5236   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5237
5238   arg1 = (Dali::Vector2 *)jarg1;
5239   {
5240     try {
5241       (arg1)->Normalize();
5242     } catch (std::out_of_range& e) {
5243       {
5244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5245       };
5246     } catch (std::exception& e) {
5247       {
5248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5249       };
5250     } catch (Dali::DaliException e) {
5251       {
5252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5253       };
5254     } catch (...) {
5255       {
5256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5257       };
5258     }
5259   }
5260
5261 }
5262
5263
5264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5265   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5266   Dali::Vector2 *arg2 = 0 ;
5267   Dali::Vector2 *arg3 = 0 ;
5268
5269   arg1 = (Dali::Vector2 *)jarg1;
5270   arg2 = (Dali::Vector2 *)jarg2;
5271   if (!arg2) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5273     return ;
5274   }
5275   arg3 = (Dali::Vector2 *)jarg3;
5276   if (!arg3) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5278     return ;
5279   }
5280   {
5281     try {
5282       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5283     } catch (std::out_of_range& e) {
5284       {
5285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5286       };
5287     } catch (std::exception& e) {
5288       {
5289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5290       };
5291     } catch (Dali::DaliException e) {
5292       {
5293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5294       };
5295     } catch (...) {
5296       {
5297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5298       };
5299     }
5300   }
5301
5302 }
5303
5304
5305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5306   void * jresult ;
5307   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5308   float *result = 0 ;
5309
5310   arg1 = (Dali::Vector2 *)jarg1;
5311   {
5312     try {
5313       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5314     } catch (std::out_of_range& e) {
5315       {
5316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5317       };
5318     } catch (std::exception& e) {
5319       {
5320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5321       };
5322     } catch (Dali::DaliException e) {
5323       {
5324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5325       };
5326     } catch (...) {
5327       {
5328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5329       };
5330     }
5331   }
5332
5333   jresult = (void *)result;
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5339   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5340   float arg2 ;
5341
5342   arg1 = (Dali::Vector2 *)jarg1;
5343   arg2 = (float)jarg2;
5344   if (arg1) (arg1)->x = arg2;
5345 }
5346
5347
5348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5349   float jresult ;
5350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5351   float result;
5352
5353   arg1 = (Dali::Vector2 *)jarg1;
5354   result = (float) ((arg1)->x);
5355   jresult = result;
5356   return jresult;
5357 }
5358
5359
5360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5362   float arg2 ;
5363
5364   arg1 = (Dali::Vector2 *)jarg1;
5365   arg2 = (float)jarg2;
5366   if (arg1) (arg1)->width = arg2;
5367 }
5368
5369
5370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5371   float jresult ;
5372   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5373   float result;
5374
5375   arg1 = (Dali::Vector2 *)jarg1;
5376   result = (float) ((arg1)->width);
5377   jresult = result;
5378   return jresult;
5379 }
5380
5381
5382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5383   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5384   float arg2 ;
5385
5386   arg1 = (Dali::Vector2 *)jarg1;
5387   arg2 = (float)jarg2;
5388   if (arg1) (arg1)->y = arg2;
5389 }
5390
5391
5392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5393   float jresult ;
5394   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5395   float result;
5396
5397   arg1 = (Dali::Vector2 *)jarg1;
5398   result = (float) ((arg1)->y);
5399   jresult = result;
5400   return jresult;
5401 }
5402
5403
5404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5405   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5406   float arg2 ;
5407
5408   arg1 = (Dali::Vector2 *)jarg1;
5409   arg2 = (float)jarg2;
5410   if (arg1) (arg1)->height = arg2;
5411 }
5412
5413
5414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5415   float jresult ;
5416   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5417   float result;
5418
5419   arg1 = (Dali::Vector2 *)jarg1;
5420   result = (float) ((arg1)->height);
5421   jresult = result;
5422   return jresult;
5423 }
5424
5425
5426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5427   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5428
5429   arg1 = (Dali::Vector2 *)jarg1;
5430   {
5431     try {
5432       delete arg1;
5433     } catch (std::out_of_range& e) {
5434       {
5435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5436       };
5437     } catch (std::exception& e) {
5438       {
5439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5440       };
5441     } catch (Dali::DaliException e) {
5442       {
5443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5444       };
5445     } catch (...) {
5446       {
5447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5448       };
5449     }
5450   }
5451
5452 }
5453
5454
5455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5456   void * jresult ;
5457   Dali::Vector2 *arg1 = 0 ;
5458   Dali::Vector2 *arg2 = 0 ;
5459   Dali::Vector2 result;
5460
5461   arg1 = (Dali::Vector2 *)jarg1;
5462   if (!arg1) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5464     return 0;
5465   }
5466   arg2 = (Dali::Vector2 *)jarg2;
5467   if (!arg2) {
5468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5469     return 0;
5470   }
5471   {
5472     try {
5473       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5474     } catch (std::out_of_range& e) {
5475       {
5476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5477       };
5478     } catch (std::exception& e) {
5479       {
5480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5481       };
5482     } catch (Dali::DaliException e) {
5483       {
5484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5485       };
5486     } catch (...) {
5487       {
5488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5489       };
5490     }
5491   }
5492
5493   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5494   return jresult;
5495 }
5496
5497
5498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5499   void * jresult ;
5500   Dali::Vector2 *arg1 = 0 ;
5501   Dali::Vector2 *arg2 = 0 ;
5502   Dali::Vector2 result;
5503
5504   arg1 = (Dali::Vector2 *)jarg1;
5505   if (!arg1) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   arg2 = (Dali::Vector2 *)jarg2;
5510   if (!arg2) {
5511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5512     return 0;
5513   }
5514   {
5515     try {
5516       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (Dali::DaliException e) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5528       };
5529     } catch (...) {
5530       {
5531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5532       };
5533     }
5534   }
5535
5536   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5537   return jresult;
5538 }
5539
5540
5541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5542   void * jresult ;
5543   Dali::Vector2 *arg1 = 0 ;
5544   float *arg2 = 0 ;
5545   float *arg3 = 0 ;
5546   float temp2 ;
5547   float temp3 ;
5548   Dali::Vector2 result;
5549
5550   arg1 = (Dali::Vector2 *)jarg1;
5551   if (!arg1) {
5552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5553     return 0;
5554   }
5555   temp2 = (float)jarg2;
5556   arg2 = &temp2;
5557   temp3 = (float)jarg3;
5558   arg3 = &temp3;
5559   {
5560     try {
5561       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5562     } catch (std::out_of_range& e) {
5563       {
5564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5565       };
5566     } catch (std::exception& e) {
5567       {
5568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5569       };
5570     } catch (Dali::DaliException e) {
5571       {
5572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5573       };
5574     } catch (...) {
5575       {
5576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5577       };
5578     }
5579   }
5580
5581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5582   return jresult;
5583 }
5584
5585
5586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5587   void * jresult ;
5588   Dali::Vector3 *result = 0 ;
5589
5590   {
5591     try {
5592       result = (Dali::Vector3 *)new Dali::Vector3();
5593     } catch (std::out_of_range& e) {
5594       {
5595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5596       };
5597     } catch (std::exception& e) {
5598       {
5599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5600       };
5601     } catch (Dali::DaliException e) {
5602       {
5603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5604       };
5605     } catch (...) {
5606       {
5607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5608       };
5609     }
5610   }
5611
5612   jresult = (void *)result;
5613   return jresult;
5614 }
5615
5616
5617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5618   void * jresult ;
5619   float arg1 ;
5620   float arg2 ;
5621   float arg3 ;
5622   Dali::Vector3 *result = 0 ;
5623
5624   arg1 = (float)jarg1;
5625   arg2 = (float)jarg2;
5626   arg3 = (float)jarg3;
5627   {
5628     try {
5629       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5630     } catch (std::out_of_range& e) {
5631       {
5632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5633       };
5634     } catch (std::exception& e) {
5635       {
5636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (Dali::DaliException e) {
5639       {
5640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5641       };
5642     } catch (...) {
5643       {
5644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5645       };
5646     }
5647   }
5648
5649   jresult = (void *)result;
5650   return jresult;
5651 }
5652
5653
5654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5655   void * jresult ;
5656   float *arg1 = (float *) 0 ;
5657   Dali::Vector3 *result = 0 ;
5658
5659   arg1 = jarg1;
5660   {
5661     try {
5662       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5663     } catch (std::out_of_range& e) {
5664       {
5665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5666       };
5667     } catch (std::exception& e) {
5668       {
5669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5670       };
5671     } catch (Dali::DaliException e) {
5672       {
5673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5674       };
5675     } catch (...) {
5676       {
5677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5678       };
5679     }
5680   }
5681
5682   jresult = (void *)result;
5683
5684
5685   return jresult;
5686 }
5687
5688
5689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5690   void * jresult ;
5691   Dali::Vector2 *arg1 = 0 ;
5692   Dali::Vector3 *result = 0 ;
5693
5694   arg1 = (Dali::Vector2 *)jarg1;
5695   if (!arg1) {
5696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5697     return 0;
5698   }
5699   {
5700     try {
5701       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5702     } catch (std::out_of_range& e) {
5703       {
5704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5705       };
5706     } catch (std::exception& e) {
5707       {
5708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5709       };
5710     } catch (Dali::DaliException e) {
5711       {
5712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5713       };
5714     } catch (...) {
5715       {
5716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5717       };
5718     }
5719   }
5720
5721   jresult = (void *)result;
5722   return jresult;
5723 }
5724
5725
5726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5727   void * jresult ;
5728   Dali::Vector4 *arg1 = 0 ;
5729   Dali::Vector3 *result = 0 ;
5730
5731   arg1 = (Dali::Vector4 *)jarg1;
5732   if (!arg1) {
5733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5734     return 0;
5735   }
5736   {
5737     try {
5738       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (Dali::DaliException e) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5750       };
5751     } catch (...) {
5752       {
5753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5754       };
5755     }
5756   }
5757
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5814   void * jresult ;
5815   Dali::Vector3 *result = 0 ;
5816
5817   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5818   jresult = (void *)result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5824   void * jresult ;
5825   Dali::Vector3 *result = 0 ;
5826
5827   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5828   jresult = (void *)result;
5829   return jresult;
5830 }
5831
5832
5833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5834   void * jresult ;
5835   Dali::Vector3 *result = 0 ;
5836
5837   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5838   jresult = (void *)result;
5839   return jresult;
5840 }
5841
5842
5843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5844   void * jresult ;
5845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5846   float *arg2 = (float *) 0 ;
5847   Dali::Vector3 *result = 0 ;
5848
5849   arg1 = (Dali::Vector3 *)jarg1;
5850   arg2 = jarg2;
5851   {
5852     try {
5853       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5854     } catch (std::out_of_range& e) {
5855       {
5856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (std::exception& e) {
5859       {
5860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5861       };
5862     } catch (Dali::DaliException e) {
5863       {
5864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5865       };
5866     } catch (...) {
5867       {
5868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5869       };
5870     }
5871   }
5872
5873   jresult = (void *)result;
5874
5875
5876   return jresult;
5877 }
5878
5879
5880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5881   void * jresult ;
5882   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5883   Dali::Vector2 *arg2 = 0 ;
5884   Dali::Vector3 *result = 0 ;
5885
5886   arg1 = (Dali::Vector3 *)jarg1;
5887   arg2 = (Dali::Vector2 *)jarg2;
5888   if (!arg2) {
5889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5890     return 0;
5891   }
5892   {
5893     try {
5894       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5895     } catch (std::out_of_range& e) {
5896       {
5897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5898       };
5899     } catch (std::exception& e) {
5900       {
5901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5902       };
5903     } catch (Dali::DaliException e) {
5904       {
5905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5906       };
5907     } catch (...) {
5908       {
5909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5910       };
5911     }
5912   }
5913
5914   jresult = (void *)result;
5915   return jresult;
5916 }
5917
5918
5919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5920   void * jresult ;
5921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5922   Dali::Vector4 *arg2 = 0 ;
5923   Dali::Vector3 *result = 0 ;
5924
5925   arg1 = (Dali::Vector3 *)jarg1;
5926   arg2 = (Dali::Vector4 *)jarg2;
5927   if (!arg2) {
5928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5929     return 0;
5930   }
5931   {
5932     try {
5933       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5934     } catch (std::out_of_range& e) {
5935       {
5936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5937       };
5938     } catch (std::exception& e) {
5939       {
5940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5941       };
5942     } catch (Dali::DaliException e) {
5943       {
5944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5945       };
5946     } catch (...) {
5947       {
5948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5949       };
5950     }
5951   }
5952
5953   jresult = (void *)result;
5954   return jresult;
5955 }
5956
5957
5958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5959   void * jresult ;
5960   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5961   Dali::Vector3 *arg2 = 0 ;
5962   Dali::Vector3 result;
5963
5964   arg1 = (Dali::Vector3 *)jarg1;
5965   arg2 = (Dali::Vector3 *)jarg2;
5966   if (!arg2) {
5967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5968     return 0;
5969   }
5970   {
5971     try {
5972       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5973     } catch (std::out_of_range& e) {
5974       {
5975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5976       };
5977     } catch (std::exception& e) {
5978       {
5979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5980       };
5981     } catch (Dali::DaliException e) {
5982       {
5983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5984       };
5985     } catch (...) {
5986       {
5987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5988       };
5989     }
5990   }
5991
5992   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5993   return jresult;
5994 }
5995
5996
5997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5998   void * jresult ;
5999   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6000   Dali::Vector3 *arg2 = 0 ;
6001   Dali::Vector3 *result = 0 ;
6002
6003   arg1 = (Dali::Vector3 *)jarg1;
6004   arg2 = (Dali::Vector3 *)jarg2;
6005   if (!arg2) {
6006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6007     return 0;
6008   }
6009   {
6010     try {
6011       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6012     } catch (std::out_of_range& e) {
6013       {
6014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6015       };
6016     } catch (std::exception& e) {
6017       {
6018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6019       };
6020     } catch (Dali::DaliException e) {
6021       {
6022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6023       };
6024     } catch (...) {
6025       {
6026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6027       };
6028     }
6029   }
6030
6031   jresult = (void *)result;
6032   return jresult;
6033 }
6034
6035
6036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6037   void * jresult ;
6038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6039   Dali::Vector3 *arg2 = 0 ;
6040   Dali::Vector3 result;
6041
6042   arg1 = (Dali::Vector3 *)jarg1;
6043   arg2 = (Dali::Vector3 *)jarg2;
6044   if (!arg2) {
6045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6046     return 0;
6047   }
6048   {
6049     try {
6050       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6051     } catch (std::out_of_range& e) {
6052       {
6053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6054       };
6055     } catch (std::exception& e) {
6056       {
6057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6058       };
6059     } catch (Dali::DaliException e) {
6060       {
6061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6062       };
6063     } catch (...) {
6064       {
6065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6066       };
6067     }
6068   }
6069
6070   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6071   return jresult;
6072 }
6073
6074
6075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6076   void * jresult ;
6077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6078   Dali::Vector3 *arg2 = 0 ;
6079   Dali::Vector3 *result = 0 ;
6080
6081   arg1 = (Dali::Vector3 *)jarg1;
6082   arg2 = (Dali::Vector3 *)jarg2;
6083   if (!arg2) {
6084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6085     return 0;
6086   }
6087   {
6088     try {
6089       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6090     } catch (std::out_of_range& e) {
6091       {
6092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6093       };
6094     } catch (std::exception& e) {
6095       {
6096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6097       };
6098     } catch (Dali::DaliException e) {
6099       {
6100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6101       };
6102     } catch (...) {
6103       {
6104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6105       };
6106     }
6107   }
6108
6109   jresult = (void *)result;
6110   return jresult;
6111 }
6112
6113
6114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6115   void * jresult ;
6116   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6117   Dali::Vector3 *arg2 = 0 ;
6118   Dali::Vector3 result;
6119
6120   arg1 = (Dali::Vector3 *)jarg1;
6121   arg2 = (Dali::Vector3 *)jarg2;
6122   if (!arg2) {
6123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6124     return 0;
6125   }
6126   {
6127     try {
6128       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6129     } catch (std::out_of_range& e) {
6130       {
6131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6132       };
6133     } catch (std::exception& e) {
6134       {
6135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6136       };
6137     } catch (Dali::DaliException e) {
6138       {
6139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6140       };
6141     } catch (...) {
6142       {
6143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6144       };
6145     }
6146   }
6147
6148   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6149   return jresult;
6150 }
6151
6152
6153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6154   void * jresult ;
6155   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6156   float arg2 ;
6157   Dali::Vector3 result;
6158
6159   arg1 = (Dali::Vector3 *)jarg1;
6160   arg2 = (float)jarg2;
6161   {
6162     try {
6163       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6164     } catch (std::out_of_range& e) {
6165       {
6166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6167       };
6168     } catch (std::exception& e) {
6169       {
6170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (Dali::DaliException e) {
6173       {
6174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6175       };
6176     } catch (...) {
6177       {
6178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6179       };
6180     }
6181   }
6182
6183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6184   return jresult;
6185 }
6186
6187
6188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6189   void * jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   Dali::Vector3 *arg2 = 0 ;
6192   Dali::Vector3 *result = 0 ;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   arg2 = (Dali::Vector3 *)jarg2;
6196   if (!arg2) {
6197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6198     return 0;
6199   }
6200   {
6201     try {
6202       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6203     } catch (std::out_of_range& e) {
6204       {
6205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6206       };
6207     } catch (std::exception& e) {
6208       {
6209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6210       };
6211     } catch (Dali::DaliException e) {
6212       {
6213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6214       };
6215     } catch (...) {
6216       {
6217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6218       };
6219     }
6220   }
6221
6222   jresult = (void *)result;
6223   return jresult;
6224 }
6225
6226
6227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6228   void * jresult ;
6229   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6230   float arg2 ;
6231   Dali::Vector3 *result = 0 ;
6232
6233   arg1 = (Dali::Vector3 *)jarg1;
6234   arg2 = (float)jarg2;
6235   {
6236     try {
6237       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6238     } catch (std::out_of_range& e) {
6239       {
6240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6241       };
6242     } catch (std::exception& e) {
6243       {
6244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6245       };
6246     } catch (Dali::DaliException e) {
6247       {
6248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6249       };
6250     } catch (...) {
6251       {
6252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6253       };
6254     }
6255   }
6256
6257   jresult = (void *)result;
6258   return jresult;
6259 }
6260
6261
6262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6263   void * jresult ;
6264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6265   Dali::Quaternion *arg2 = 0 ;
6266   Dali::Vector3 *result = 0 ;
6267
6268   arg1 = (Dali::Vector3 *)jarg1;
6269   arg2 = (Dali::Quaternion *)jarg2;
6270   if (!arg2) {
6271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6272     return 0;
6273   }
6274   {
6275     try {
6276       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6277     } catch (std::out_of_range& e) {
6278       {
6279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6280       };
6281     } catch (std::exception& e) {
6282       {
6283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6284       };
6285     } catch (Dali::DaliException e) {
6286       {
6287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6288       };
6289     } catch (...) {
6290       {
6291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6292       };
6293     }
6294   }
6295
6296   jresult = (void *)result;
6297   return jresult;
6298 }
6299
6300
6301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6302   void * jresult ;
6303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6304   Dali::Vector3 *arg2 = 0 ;
6305   Dali::Vector3 result;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   arg2 = (Dali::Vector3 *)jarg2;
6309   if (!arg2) {
6310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6311     return 0;
6312   }
6313   {
6314     try {
6315       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6316     } catch (std::out_of_range& e) {
6317       {
6318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6319       };
6320     } catch (std::exception& e) {
6321       {
6322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6323       };
6324     } catch (Dali::DaliException e) {
6325       {
6326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6327       };
6328     } catch (...) {
6329       {
6330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6331       };
6332     }
6333   }
6334
6335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6336   return jresult;
6337 }
6338
6339
6340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6341   void * jresult ;
6342   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6343   float arg2 ;
6344   Dali::Vector3 result;
6345
6346   arg1 = (Dali::Vector3 *)jarg1;
6347   arg2 = (float)jarg2;
6348   {
6349     try {
6350       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6351     } catch (std::out_of_range& e) {
6352       {
6353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6354       };
6355     } catch (std::exception& e) {
6356       {
6357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6358       };
6359     } catch (Dali::DaliException e) {
6360       {
6361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6362       };
6363     } catch (...) {
6364       {
6365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6366       };
6367     }
6368   }
6369
6370   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6371   return jresult;
6372 }
6373
6374
6375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6376   void * jresult ;
6377   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6378   Dali::Vector3 *arg2 = 0 ;
6379   Dali::Vector3 *result = 0 ;
6380
6381   arg1 = (Dali::Vector3 *)jarg1;
6382   arg2 = (Dali::Vector3 *)jarg2;
6383   if (!arg2) {
6384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6385     return 0;
6386   }
6387   {
6388     try {
6389       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6390     } catch (std::out_of_range& e) {
6391       {
6392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6393       };
6394     } catch (std::exception& e) {
6395       {
6396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6397       };
6398     } catch (Dali::DaliException e) {
6399       {
6400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6401       };
6402     } catch (...) {
6403       {
6404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6405       };
6406     }
6407   }
6408
6409   jresult = (void *)result;
6410   return jresult;
6411 }
6412
6413
6414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6415   void * jresult ;
6416   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6417   float arg2 ;
6418   Dali::Vector3 *result = 0 ;
6419
6420   arg1 = (Dali::Vector3 *)jarg1;
6421   arg2 = (float)jarg2;
6422   {
6423     try {
6424       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6425     } catch (std::out_of_range& e) {
6426       {
6427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6428       };
6429     } catch (std::exception& e) {
6430       {
6431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6432       };
6433     } catch (Dali::DaliException e) {
6434       {
6435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6436       };
6437     } catch (...) {
6438       {
6439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6440       };
6441     }
6442   }
6443
6444   jresult = (void *)result;
6445   return jresult;
6446 }
6447
6448
6449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6450   void * jresult ;
6451   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6452   Dali::Vector3 result;
6453
6454   arg1 = (Dali::Vector3 *)jarg1;
6455   {
6456     try {
6457       result = ((Dali::Vector3 const *)arg1)->operator -();
6458     } catch (std::out_of_range& e) {
6459       {
6460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6461       };
6462     } catch (std::exception& e) {
6463       {
6464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6465       };
6466     } catch (Dali::DaliException e) {
6467       {
6468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6469       };
6470     } catch (...) {
6471       {
6472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6473       };
6474     }
6475   }
6476
6477   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6478   return jresult;
6479 }
6480
6481
6482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6483   unsigned int jresult ;
6484   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6485   Dali::Vector3 *arg2 = 0 ;
6486   bool result;
6487
6488   arg1 = (Dali::Vector3 *)jarg1;
6489   arg2 = (Dali::Vector3 *)jarg2;
6490   if (!arg2) {
6491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6492     return 0;
6493   }
6494   {
6495     try {
6496       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6497     } catch (std::out_of_range& e) {
6498       {
6499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6500       };
6501     } catch (std::exception& e) {
6502       {
6503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6504       };
6505     } catch (Dali::DaliException e) {
6506       {
6507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6508       };
6509     } catch (...) {
6510       {
6511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6512       };
6513     }
6514   }
6515
6516   jresult = result;
6517   return jresult;
6518 }
6519
6520
6521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6522   unsigned int jresult ;
6523   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6524   Dali::Vector3 *arg2 = 0 ;
6525   bool result;
6526
6527   arg1 = (Dali::Vector3 *)jarg1;
6528   arg2 = (Dali::Vector3 *)jarg2;
6529   if (!arg2) {
6530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6531     return 0;
6532   }
6533   {
6534     try {
6535       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6536     } catch (std::out_of_range& e) {
6537       {
6538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6539       };
6540     } catch (std::exception& e) {
6541       {
6542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6543       };
6544     } catch (Dali::DaliException e) {
6545       {
6546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6547       };
6548     } catch (...) {
6549       {
6550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6551       };
6552     }
6553   }
6554
6555   jresult = result;
6556   return jresult;
6557 }
6558
6559
6560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6561   float jresult ;
6562   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6563   unsigned int arg2 ;
6564   float *result = 0 ;
6565
6566   arg1 = (Dali::Vector3 *)jarg1;
6567   arg2 = (unsigned int)jarg2;
6568   {
6569     try {
6570       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6571     } catch (std::out_of_range& e) {
6572       {
6573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6574       };
6575     } catch (std::exception& e) {
6576       {
6577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6578       };
6579     } catch (Dali::DaliException e) {
6580       {
6581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6582       };
6583     } catch (...) {
6584       {
6585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6586       };
6587     }
6588   }
6589
6590   jresult = *result;
6591   return jresult;
6592 }
6593
6594
6595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6596   float jresult ;
6597   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6598   Dali::Vector3 *arg2 = 0 ;
6599   float result;
6600
6601   arg1 = (Dali::Vector3 *)jarg1;
6602   arg2 = (Dali::Vector3 *)jarg2;
6603   if (!arg2) {
6604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6605     return 0;
6606   }
6607   {
6608     try {
6609       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6610     } catch (std::out_of_range& e) {
6611       {
6612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6613       };
6614     } catch (std::exception& e) {
6615       {
6616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6617       };
6618     } catch (Dali::DaliException e) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6621       };
6622     } catch (...) {
6623       {
6624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6625       };
6626     }
6627   }
6628
6629   jresult = result;
6630   return jresult;
6631 }
6632
6633
6634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6635   void * jresult ;
6636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6637   Dali::Vector3 *arg2 = 0 ;
6638   Dali::Vector3 result;
6639
6640   arg1 = (Dali::Vector3 *)jarg1;
6641   arg2 = (Dali::Vector3 *)jarg2;
6642   if (!arg2) {
6643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6644     return 0;
6645   }
6646   {
6647     try {
6648       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6649     } catch (std::out_of_range& e) {
6650       {
6651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6652       };
6653     } catch (std::exception& e) {
6654       {
6655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6656       };
6657     } catch (Dali::DaliException e) {
6658       {
6659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6660       };
6661     } catch (...) {
6662       {
6663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6664       };
6665     }
6666   }
6667
6668   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6669   return jresult;
6670 }
6671
6672
6673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6674   float jresult ;
6675   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6676   float result;
6677
6678   arg1 = (Dali::Vector3 *)jarg1;
6679   {
6680     try {
6681       result = (float)((Dali::Vector3 const *)arg1)->Length();
6682     } catch (std::out_of_range& e) {
6683       {
6684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6685       };
6686     } catch (std::exception& e) {
6687       {
6688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6689       };
6690     } catch (Dali::DaliException e) {
6691       {
6692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6693       };
6694     } catch (...) {
6695       {
6696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6697       };
6698     }
6699   }
6700
6701   jresult = result;
6702   return jresult;
6703 }
6704
6705
6706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6707   float jresult ;
6708   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6709   float result;
6710
6711   arg1 = (Dali::Vector3 *)jarg1;
6712   {
6713     try {
6714       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6715     } catch (std::out_of_range& e) {
6716       {
6717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6718       };
6719     } catch (std::exception& e) {
6720       {
6721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6722       };
6723     } catch (Dali::DaliException e) {
6724       {
6725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6726       };
6727     } catch (...) {
6728       {
6729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6730       };
6731     }
6732   }
6733
6734   jresult = result;
6735   return jresult;
6736 }
6737
6738
6739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6740   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6741
6742   arg1 = (Dali::Vector3 *)jarg1;
6743   {
6744     try {
6745       (arg1)->Normalize();
6746     } catch (std::out_of_range& e) {
6747       {
6748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6749       };
6750     } catch (std::exception& e) {
6751       {
6752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6753       };
6754     } catch (Dali::DaliException e) {
6755       {
6756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6757       };
6758     } catch (...) {
6759       {
6760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6761       };
6762     }
6763   }
6764
6765 }
6766
6767
6768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6769   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6770   Dali::Vector3 *arg2 = 0 ;
6771   Dali::Vector3 *arg3 = 0 ;
6772
6773   arg1 = (Dali::Vector3 *)jarg1;
6774   arg2 = (Dali::Vector3 *)jarg2;
6775   if (!arg2) {
6776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6777     return ;
6778   }
6779   arg3 = (Dali::Vector3 *)jarg3;
6780   if (!arg3) {
6781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6782     return ;
6783   }
6784   {
6785     try {
6786       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6787     } catch (std::out_of_range& e) {
6788       {
6789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6790       };
6791     } catch (std::exception& e) {
6792       {
6793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6794       };
6795     } catch (Dali::DaliException e) {
6796       {
6797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6798       };
6799     } catch (...) {
6800       {
6801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6802       };
6803     }
6804   }
6805
6806 }
6807
6808
6809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6810   void * jresult ;
6811   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6812   float *result = 0 ;
6813
6814   arg1 = (Dali::Vector3 *)jarg1;
6815   {
6816     try {
6817       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6818     } catch (std::out_of_range& e) {
6819       {
6820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6821       };
6822     } catch (std::exception& e) {
6823       {
6824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6825       };
6826     } catch (Dali::DaliException e) {
6827       {
6828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6829       };
6830     } catch (...) {
6831       {
6832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6833       };
6834     }
6835   }
6836
6837   jresult = (void *)result;
6838   return jresult;
6839 }
6840
6841
6842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6843   void * jresult ;
6844   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6845   Dali::Vector2 *result = 0 ;
6846
6847   arg1 = (Dali::Vector3 *)jarg1;
6848   {
6849     try {
6850       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6851     } catch (std::out_of_range& e) {
6852       {
6853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6854       };
6855     } catch (std::exception& e) {
6856       {
6857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6858       };
6859     } catch (Dali::DaliException e) {
6860       {
6861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6862       };
6863     } catch (...) {
6864       {
6865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6866       };
6867     }
6868   }
6869
6870   jresult = (void *)result;
6871   return jresult;
6872 }
6873
6874
6875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6876   void * jresult ;
6877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6878   Dali::Vector2 *result = 0 ;
6879
6880   arg1 = (Dali::Vector3 *)jarg1;
6881   {
6882     try {
6883       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6884     } catch (std::out_of_range& e) {
6885       {
6886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6887       };
6888     } catch (std::exception& e) {
6889       {
6890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6891       };
6892     } catch (Dali::DaliException e) {
6893       {
6894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6895       };
6896     } catch (...) {
6897       {
6898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6899       };
6900     }
6901   }
6902
6903   jresult = (void *)result;
6904   return jresult;
6905 }
6906
6907
6908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6909   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6910   float arg2 ;
6911
6912   arg1 = (Dali::Vector3 *)jarg1;
6913   arg2 = (float)jarg2;
6914   if (arg1) (arg1)->x = arg2;
6915 }
6916
6917
6918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6919   float jresult ;
6920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6921   float result;
6922
6923   arg1 = (Dali::Vector3 *)jarg1;
6924   result = (float) ((arg1)->x);
6925   jresult = result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6931   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6932   float arg2 ;
6933
6934   arg1 = (Dali::Vector3 *)jarg1;
6935   arg2 = (float)jarg2;
6936   if (arg1) (arg1)->width = arg2;
6937 }
6938
6939
6940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6941   float jresult ;
6942   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6943   float result;
6944
6945   arg1 = (Dali::Vector3 *)jarg1;
6946   result = (float) ((arg1)->width);
6947   jresult = result;
6948   return jresult;
6949 }
6950
6951
6952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6954   float arg2 ;
6955
6956   arg1 = (Dali::Vector3 *)jarg1;
6957   arg2 = (float)jarg2;
6958   if (arg1) (arg1)->r = arg2;
6959 }
6960
6961
6962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6963   float jresult ;
6964   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6965   float result;
6966
6967   arg1 = (Dali::Vector3 *)jarg1;
6968   result = (float) ((arg1)->r);
6969   jresult = result;
6970   return jresult;
6971 }
6972
6973
6974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6975   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6976   float arg2 ;
6977
6978   arg1 = (Dali::Vector3 *)jarg1;
6979   arg2 = (float)jarg2;
6980   if (arg1) (arg1)->y = arg2;
6981 }
6982
6983
6984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6985   float jresult ;
6986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6987   float result;
6988
6989   arg1 = (Dali::Vector3 *)jarg1;
6990   result = (float) ((arg1)->y);
6991   jresult = result;
6992   return jresult;
6993 }
6994
6995
6996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6997   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6998   float arg2 ;
6999
7000   arg1 = (Dali::Vector3 *)jarg1;
7001   arg2 = (float)jarg2;
7002   if (arg1) (arg1)->height = arg2;
7003 }
7004
7005
7006 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7007   float jresult ;
7008   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7009   float result;
7010
7011   arg1 = (Dali::Vector3 *)jarg1;
7012   result = (float) ((arg1)->height);
7013   jresult = result;
7014   return jresult;
7015 }
7016
7017
7018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7019   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7020   float arg2 ;
7021
7022   arg1 = (Dali::Vector3 *)jarg1;
7023   arg2 = (float)jarg2;
7024   if (arg1) (arg1)->g = arg2;
7025 }
7026
7027
7028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7029   float jresult ;
7030   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7031   float result;
7032
7033   arg1 = (Dali::Vector3 *)jarg1;
7034   result = (float) ((arg1)->g);
7035   jresult = result;
7036   return jresult;
7037 }
7038
7039
7040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7042   float arg2 ;
7043
7044   arg1 = (Dali::Vector3 *)jarg1;
7045   arg2 = (float)jarg2;
7046   if (arg1) (arg1)->z = arg2;
7047 }
7048
7049
7050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7051   float jresult ;
7052   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7053   float result;
7054
7055   arg1 = (Dali::Vector3 *)jarg1;
7056   result = (float) ((arg1)->z);
7057   jresult = result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7063   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7064   float arg2 ;
7065
7066   arg1 = (Dali::Vector3 *)jarg1;
7067   arg2 = (float)jarg2;
7068   if (arg1) (arg1)->depth = arg2;
7069 }
7070
7071
7072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7073   float jresult ;
7074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7075   float result;
7076
7077   arg1 = (Dali::Vector3 *)jarg1;
7078   result = (float) ((arg1)->depth);
7079   jresult = result;
7080   return jresult;
7081 }
7082
7083
7084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7086   float arg2 ;
7087
7088   arg1 = (Dali::Vector3 *)jarg1;
7089   arg2 = (float)jarg2;
7090   if (arg1) (arg1)->b = arg2;
7091 }
7092
7093
7094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7095   float jresult ;
7096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7097   float result;
7098
7099   arg1 = (Dali::Vector3 *)jarg1;
7100   result = (float) ((arg1)->b);
7101   jresult = result;
7102   return jresult;
7103 }
7104
7105
7106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7107   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7108
7109   arg1 = (Dali::Vector3 *)jarg1;
7110   {
7111     try {
7112       delete arg1;
7113     } catch (std::out_of_range& e) {
7114       {
7115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7116       };
7117     } catch (std::exception& e) {
7118       {
7119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7120       };
7121     } catch (Dali::DaliException e) {
7122       {
7123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7124       };
7125     } catch (...) {
7126       {
7127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7128       };
7129     }
7130   }
7131
7132 }
7133
7134
7135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7136   void * jresult ;
7137   Dali::Vector3 *arg1 = 0 ;
7138   Dali::Vector3 *arg2 = 0 ;
7139   Dali::Vector3 result;
7140
7141   arg1 = (Dali::Vector3 *)jarg1;
7142   if (!arg1) {
7143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7144     return 0;
7145   }
7146   arg2 = (Dali::Vector3 *)jarg2;
7147   if (!arg2) {
7148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7149     return 0;
7150   }
7151   {
7152     try {
7153       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7154     } catch (std::out_of_range& e) {
7155       {
7156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7157       };
7158     } catch (std::exception& e) {
7159       {
7160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7161       };
7162     } catch (Dali::DaliException e) {
7163       {
7164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7165       };
7166     } catch (...) {
7167       {
7168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7169       };
7170     }
7171   }
7172
7173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7174   return jresult;
7175 }
7176
7177
7178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7179   void * jresult ;
7180   Dali::Vector3 *arg1 = 0 ;
7181   Dali::Vector3 *arg2 = 0 ;
7182   Dali::Vector3 result;
7183
7184   arg1 = (Dali::Vector3 *)jarg1;
7185   if (!arg1) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   arg2 = (Dali::Vector3 *)jarg2;
7190   if (!arg2) {
7191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7192     return 0;
7193   }
7194   {
7195     try {
7196       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7197     } catch (std::out_of_range& e) {
7198       {
7199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7200       };
7201     } catch (std::exception& e) {
7202       {
7203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (Dali::DaliException e) {
7206       {
7207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215
7216   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7217   return jresult;
7218 }
7219
7220
7221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7222   void * jresult ;
7223   Dali::Vector3 *arg1 = 0 ;
7224   float *arg2 = 0 ;
7225   float *arg3 = 0 ;
7226   float temp2 ;
7227   float temp3 ;
7228   Dali::Vector3 result;
7229
7230   arg1 = (Dali::Vector3 *)jarg1;
7231   if (!arg1) {
7232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7233     return 0;
7234   }
7235   temp2 = (float)jarg2;
7236   arg2 = &temp2;
7237   temp3 = (float)jarg3;
7238   arg3 = &temp3;
7239   {
7240     try {
7241       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7242     } catch (std::out_of_range& e) {
7243       {
7244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7245       };
7246     } catch (std::exception& e) {
7247       {
7248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7249       };
7250     } catch (Dali::DaliException e) {
7251       {
7252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7253       };
7254     } catch (...) {
7255       {
7256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7257       };
7258     }
7259   }
7260
7261   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7262   return jresult;
7263 }
7264
7265
7266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7267   void * jresult ;
7268   Dali::Vector4 *result = 0 ;
7269
7270   {
7271     try {
7272       result = (Dali::Vector4 *)new Dali::Vector4();
7273     } catch (std::out_of_range& e) {
7274       {
7275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7276       };
7277     } catch (std::exception& e) {
7278       {
7279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7280       };
7281     } catch (Dali::DaliException e) {
7282       {
7283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7284       };
7285     } catch (...) {
7286       {
7287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7288       };
7289     }
7290   }
7291
7292   jresult = (void *)result;
7293   return jresult;
7294 }
7295
7296
7297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7298   void * jresult ;
7299   float arg1 ;
7300   float arg2 ;
7301   float arg3 ;
7302   float arg4 ;
7303   Dali::Vector4 *result = 0 ;
7304
7305   arg1 = (float)jarg1;
7306   arg2 = (float)jarg2;
7307   arg3 = (float)jarg3;
7308   arg4 = (float)jarg4;
7309   {
7310     try {
7311       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7312     } catch (std::out_of_range& e) {
7313       {
7314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7315       };
7316     } catch (std::exception& e) {
7317       {
7318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (Dali::DaliException e) {
7321       {
7322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7323       };
7324     } catch (...) {
7325       {
7326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7327       };
7328     }
7329   }
7330
7331   jresult = (void *)result;
7332   return jresult;
7333 }
7334
7335
7336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7337   void * jresult ;
7338   float *arg1 = (float *) 0 ;
7339   Dali::Vector4 *result = 0 ;
7340
7341   arg1 = jarg1;
7342   {
7343     try {
7344       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7345     } catch (std::out_of_range& e) {
7346       {
7347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7348       };
7349     } catch (std::exception& e) {
7350       {
7351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7352       };
7353     } catch (Dali::DaliException e) {
7354       {
7355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7356       };
7357     } catch (...) {
7358       {
7359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7360       };
7361     }
7362   }
7363
7364   jresult = (void *)result;
7365
7366
7367   return jresult;
7368 }
7369
7370
7371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7372   void * jresult ;
7373   Dali::Vector2 *arg1 = 0 ;
7374   Dali::Vector4 *result = 0 ;
7375
7376   arg1 = (Dali::Vector2 *)jarg1;
7377   if (!arg1) {
7378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7379     return 0;
7380   }
7381   {
7382     try {
7383       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7384     } catch (std::out_of_range& e) {
7385       {
7386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (std::exception& e) {
7389       {
7390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7391       };
7392     } catch (Dali::DaliException e) {
7393       {
7394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7395       };
7396     } catch (...) {
7397       {
7398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7399       };
7400     }
7401   }
7402
7403   jresult = (void *)result;
7404   return jresult;
7405 }
7406
7407
7408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7409   void * jresult ;
7410   Dali::Vector3 *arg1 = 0 ;
7411   Dali::Vector4 *result = 0 ;
7412
7413   arg1 = (Dali::Vector3 *)jarg1;
7414   if (!arg1) {
7415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7416     return 0;
7417   }
7418   {
7419     try {
7420       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7421     } catch (std::out_of_range& e) {
7422       {
7423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7424       };
7425     } catch (std::exception& e) {
7426       {
7427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7428       };
7429     } catch (Dali::DaliException e) {
7430       {
7431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7432       };
7433     } catch (...) {
7434       {
7435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7436       };
7437     }
7438   }
7439
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7466   void * jresult ;
7467   Dali::Vector4 *result = 0 ;
7468
7469   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7470   jresult = (void *)result;
7471   return jresult;
7472 }
7473
7474
7475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7476   void * jresult ;
7477   Dali::Vector4 *result = 0 ;
7478
7479   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7480   jresult = (void *)result;
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7486   void * jresult ;
7487   Dali::Vector4 *result = 0 ;
7488
7489   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7490   jresult = (void *)result;
7491   return jresult;
7492 }
7493
7494
7495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7496   void * jresult ;
7497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7498   float *arg2 = (float *) 0 ;
7499   Dali::Vector4 *result = 0 ;
7500
7501   arg1 = (Dali::Vector4 *)jarg1;
7502   arg2 = jarg2;
7503   {
7504     try {
7505       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7506     } catch (std::out_of_range& e) {
7507       {
7508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7509       };
7510     } catch (std::exception& e) {
7511       {
7512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7513       };
7514     } catch (Dali::DaliException e) {
7515       {
7516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7517       };
7518     } catch (...) {
7519       {
7520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7521       };
7522     }
7523   }
7524
7525   jresult = (void *)result;
7526
7527
7528   return jresult;
7529 }
7530
7531
7532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7533   void * jresult ;
7534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7535   Dali::Vector2 *arg2 = 0 ;
7536   Dali::Vector4 *result = 0 ;
7537
7538   arg1 = (Dali::Vector4 *)jarg1;
7539   arg2 = (Dali::Vector2 *)jarg2;
7540   if (!arg2) {
7541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7542     return 0;
7543   }
7544   {
7545     try {
7546       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7547     } catch (std::out_of_range& e) {
7548       {
7549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7550       };
7551     } catch (std::exception& e) {
7552       {
7553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7554       };
7555     } catch (Dali::DaliException e) {
7556       {
7557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7558       };
7559     } catch (...) {
7560       {
7561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7562       };
7563     }
7564   }
7565
7566   jresult = (void *)result;
7567   return jresult;
7568 }
7569
7570
7571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7572   void * jresult ;
7573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7574   Dali::Vector3 *arg2 = 0 ;
7575   Dali::Vector4 *result = 0 ;
7576
7577   arg1 = (Dali::Vector4 *)jarg1;
7578   arg2 = (Dali::Vector3 *)jarg2;
7579   if (!arg2) {
7580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7581     return 0;
7582   }
7583   {
7584     try {
7585       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7586     } catch (std::out_of_range& e) {
7587       {
7588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7589       };
7590     } catch (std::exception& e) {
7591       {
7592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7593       };
7594     } catch (Dali::DaliException e) {
7595       {
7596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7597       };
7598     } catch (...) {
7599       {
7600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7601       };
7602     }
7603   }
7604
7605   jresult = (void *)result;
7606   return jresult;
7607 }
7608
7609
7610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7611   void * jresult ;
7612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7613   Dali::Vector4 *arg2 = 0 ;
7614   Dali::Vector4 result;
7615
7616   arg1 = (Dali::Vector4 *)jarg1;
7617   arg2 = (Dali::Vector4 *)jarg2;
7618   if (!arg2) {
7619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7620     return 0;
7621   }
7622   {
7623     try {
7624       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7625     } catch (std::out_of_range& e) {
7626       {
7627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7628       };
7629     } catch (std::exception& e) {
7630       {
7631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7632       };
7633     } catch (Dali::DaliException e) {
7634       {
7635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7636       };
7637     } catch (...) {
7638       {
7639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7640       };
7641     }
7642   }
7643
7644   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7645   return jresult;
7646 }
7647
7648
7649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7650   void * jresult ;
7651   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7652   Dali::Vector4 *arg2 = 0 ;
7653   Dali::Vector4 *result = 0 ;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   arg2 = (Dali::Vector4 *)jarg2;
7657   if (!arg2) {
7658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7659     return 0;
7660   }
7661   {
7662     try {
7663       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7664     } catch (std::out_of_range& e) {
7665       {
7666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7667       };
7668     } catch (std::exception& e) {
7669       {
7670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7671       };
7672     } catch (Dali::DaliException e) {
7673       {
7674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7675       };
7676     } catch (...) {
7677       {
7678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7679       };
7680     }
7681   }
7682
7683   jresult = (void *)result;
7684   return jresult;
7685 }
7686
7687
7688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7689   void * jresult ;
7690   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7691   Dali::Vector4 *arg2 = 0 ;
7692   Dali::Vector4 result;
7693
7694   arg1 = (Dali::Vector4 *)jarg1;
7695   arg2 = (Dali::Vector4 *)jarg2;
7696   if (!arg2) {
7697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7698     return 0;
7699   }
7700   {
7701     try {
7702       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7703     } catch (std::out_of_range& e) {
7704       {
7705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7706       };
7707     } catch (std::exception& e) {
7708       {
7709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7710       };
7711     } catch (Dali::DaliException e) {
7712       {
7713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7714       };
7715     } catch (...) {
7716       {
7717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7718       };
7719     }
7720   }
7721
7722   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7723   return jresult;
7724 }
7725
7726
7727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7728   void * jresult ;
7729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7730   Dali::Vector4 *arg2 = 0 ;
7731   Dali::Vector4 *result = 0 ;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   arg2 = (Dali::Vector4 *)jarg2;
7735   if (!arg2) {
7736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7737     return 0;
7738   }
7739   {
7740     try {
7741       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7742     } catch (std::out_of_range& e) {
7743       {
7744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7745       };
7746     } catch (std::exception& e) {
7747       {
7748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7749       };
7750     } catch (Dali::DaliException e) {
7751       {
7752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7753       };
7754     } catch (...) {
7755       {
7756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7757       };
7758     }
7759   }
7760
7761   jresult = (void *)result;
7762   return jresult;
7763 }
7764
7765
7766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7767   void * jresult ;
7768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7769   Dali::Vector4 *arg2 = 0 ;
7770   Dali::Vector4 result;
7771
7772   arg1 = (Dali::Vector4 *)jarg1;
7773   arg2 = (Dali::Vector4 *)jarg2;
7774   if (!arg2) {
7775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7776     return 0;
7777   }
7778   {
7779     try {
7780       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7781     } catch (std::out_of_range& e) {
7782       {
7783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7784       };
7785     } catch (std::exception& e) {
7786       {
7787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7788       };
7789     } catch (Dali::DaliException e) {
7790       {
7791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7792       };
7793     } catch (...) {
7794       {
7795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7796       };
7797     }
7798   }
7799
7800   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7801   return jresult;
7802 }
7803
7804
7805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7806   void * jresult ;
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float arg2 ;
7809   Dali::Vector4 result;
7810
7811   arg1 = (Dali::Vector4 *)jarg1;
7812   arg2 = (float)jarg2;
7813   {
7814     try {
7815       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7816     } catch (std::out_of_range& e) {
7817       {
7818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7819       };
7820     } catch (std::exception& e) {
7821       {
7822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7823       };
7824     } catch (Dali::DaliException e) {
7825       {
7826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7827       };
7828     } catch (...) {
7829       {
7830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7831       };
7832     }
7833   }
7834
7835   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7836   return jresult;
7837 }
7838
7839
7840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7841   void * jresult ;
7842   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7843   Dali::Vector4 *arg2 = 0 ;
7844   Dali::Vector4 *result = 0 ;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   arg2 = (Dali::Vector4 *)jarg2;
7848   if (!arg2) {
7849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7850     return 0;
7851   }
7852   {
7853     try {
7854       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7855     } catch (std::out_of_range& e) {
7856       {
7857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7858       };
7859     } catch (std::exception& e) {
7860       {
7861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7862       };
7863     } catch (Dali::DaliException e) {
7864       {
7865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7866       };
7867     } catch (...) {
7868       {
7869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7870       };
7871     }
7872   }
7873
7874   jresult = (void *)result;
7875   return jresult;
7876 }
7877
7878
7879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7880   void * jresult ;
7881   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7882   float arg2 ;
7883   Dali::Vector4 *result = 0 ;
7884
7885   arg1 = (Dali::Vector4 *)jarg1;
7886   arg2 = (float)jarg2;
7887   {
7888     try {
7889       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7890     } catch (std::out_of_range& e) {
7891       {
7892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7893       };
7894     } catch (std::exception& e) {
7895       {
7896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7897       };
7898     } catch (Dali::DaliException e) {
7899       {
7900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7901       };
7902     } catch (...) {
7903       {
7904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7905       };
7906     }
7907   }
7908
7909   jresult = (void *)result;
7910   return jresult;
7911 }
7912
7913
7914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7915   void * jresult ;
7916   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7917   Dali::Vector4 *arg2 = 0 ;
7918   Dali::Vector4 result;
7919
7920   arg1 = (Dali::Vector4 *)jarg1;
7921   arg2 = (Dali::Vector4 *)jarg2;
7922   if (!arg2) {
7923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7924     return 0;
7925   }
7926   {
7927     try {
7928       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7929     } catch (std::out_of_range& e) {
7930       {
7931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7932       };
7933     } catch (std::exception& e) {
7934       {
7935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7936       };
7937     } catch (Dali::DaliException e) {
7938       {
7939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7940       };
7941     } catch (...) {
7942       {
7943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7944       };
7945     }
7946   }
7947
7948   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7949   return jresult;
7950 }
7951
7952
7953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7954   void * jresult ;
7955   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7956   float arg2 ;
7957   Dali::Vector4 result;
7958
7959   arg1 = (Dali::Vector4 *)jarg1;
7960   arg2 = (float)jarg2;
7961   {
7962     try {
7963       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7964     } catch (std::out_of_range& e) {
7965       {
7966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7967       };
7968     } catch (std::exception& e) {
7969       {
7970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7971       };
7972     } catch (Dali::DaliException e) {
7973       {
7974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7975       };
7976     } catch (...) {
7977       {
7978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7979       };
7980     }
7981   }
7982
7983   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7984   return jresult;
7985 }
7986
7987
7988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7989   void * jresult ;
7990   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7991   Dali::Vector4 *arg2 = 0 ;
7992   Dali::Vector4 *result = 0 ;
7993
7994   arg1 = (Dali::Vector4 *)jarg1;
7995   arg2 = (Dali::Vector4 *)jarg2;
7996   if (!arg2) {
7997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7998     return 0;
7999   }
8000   {
8001     try {
8002       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8003     } catch (std::out_of_range& e) {
8004       {
8005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8006       };
8007     } catch (std::exception& e) {
8008       {
8009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8010       };
8011     } catch (Dali::DaliException e) {
8012       {
8013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8014       };
8015     } catch (...) {
8016       {
8017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8018       };
8019     }
8020   }
8021
8022   jresult = (void *)result;
8023   return jresult;
8024 }
8025
8026
8027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8028   void * jresult ;
8029   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8030   float arg2 ;
8031   Dali::Vector4 *result = 0 ;
8032
8033   arg1 = (Dali::Vector4 *)jarg1;
8034   arg2 = (float)jarg2;
8035   {
8036     try {
8037       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8038     } catch (std::out_of_range& e) {
8039       {
8040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8041       };
8042     } catch (std::exception& e) {
8043       {
8044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8045       };
8046     } catch (Dali::DaliException e) {
8047       {
8048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8049       };
8050     } catch (...) {
8051       {
8052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8053       };
8054     }
8055   }
8056
8057   jresult = (void *)result;
8058   return jresult;
8059 }
8060
8061
8062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8063   void * jresult ;
8064   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8065   Dali::Vector4 result;
8066
8067   arg1 = (Dali::Vector4 *)jarg1;
8068   {
8069     try {
8070       result = ((Dali::Vector4 const *)arg1)->operator -();
8071     } catch (std::out_of_range& e) {
8072       {
8073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8074       };
8075     } catch (std::exception& e) {
8076       {
8077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8078       };
8079     } catch (Dali::DaliException e) {
8080       {
8081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8082       };
8083     } catch (...) {
8084       {
8085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8086       };
8087     }
8088   }
8089
8090   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8091   return jresult;
8092 }
8093
8094
8095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8096   unsigned int jresult ;
8097   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8098   Dali::Vector4 *arg2 = 0 ;
8099   bool result;
8100
8101   arg1 = (Dali::Vector4 *)jarg1;
8102   arg2 = (Dali::Vector4 *)jarg2;
8103   if (!arg2) {
8104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8105     return 0;
8106   }
8107   {
8108     try {
8109       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8110     } catch (std::out_of_range& e) {
8111       {
8112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8113       };
8114     } catch (std::exception& e) {
8115       {
8116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8117       };
8118     } catch (Dali::DaliException e) {
8119       {
8120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8121       };
8122     } catch (...) {
8123       {
8124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8125       };
8126     }
8127   }
8128
8129   jresult = result;
8130   return jresult;
8131 }
8132
8133
8134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8135   unsigned int jresult ;
8136   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8137   Dali::Vector4 *arg2 = 0 ;
8138   bool result;
8139
8140   arg1 = (Dali::Vector4 *)jarg1;
8141   arg2 = (Dali::Vector4 *)jarg2;
8142   if (!arg2) {
8143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8144     return 0;
8145   }
8146   {
8147     try {
8148       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8149     } catch (std::out_of_range& e) {
8150       {
8151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8152       };
8153     } catch (std::exception& e) {
8154       {
8155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8156       };
8157     } catch (Dali::DaliException e) {
8158       {
8159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8160       };
8161     } catch (...) {
8162       {
8163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8164       };
8165     }
8166   }
8167
8168   jresult = result;
8169   return jresult;
8170 }
8171
8172
8173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8174   float jresult ;
8175   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8176   unsigned int arg2 ;
8177   float *result = 0 ;
8178
8179   arg1 = (Dali::Vector4 *)jarg1;
8180   arg2 = (unsigned int)jarg2;
8181   {
8182     try {
8183       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8184     } catch (std::out_of_range& e) {
8185       {
8186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8187       };
8188     } catch (std::exception& e) {
8189       {
8190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8191       };
8192     } catch (Dali::DaliException e) {
8193       {
8194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8195       };
8196     } catch (...) {
8197       {
8198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8199       };
8200     }
8201   }
8202
8203   jresult = *result;
8204   return jresult;
8205 }
8206
8207
8208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8209   float jresult ;
8210   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8211   Dali::Vector3 *arg2 = 0 ;
8212   float result;
8213
8214   arg1 = (Dali::Vector4 *)jarg1;
8215   arg2 = (Dali::Vector3 *)jarg2;
8216   if (!arg2) {
8217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8218     return 0;
8219   }
8220   {
8221     try {
8222       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8223     } catch (std::out_of_range& e) {
8224       {
8225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8226       };
8227     } catch (std::exception& e) {
8228       {
8229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8230       };
8231     } catch (Dali::DaliException e) {
8232       {
8233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8234       };
8235     } catch (...) {
8236       {
8237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8238       };
8239     }
8240   }
8241
8242   jresult = result;
8243   return jresult;
8244 }
8245
8246
8247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8248   float jresult ;
8249   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8250   Dali::Vector4 *arg2 = 0 ;
8251   float result;
8252
8253   arg1 = (Dali::Vector4 *)jarg1;
8254   arg2 = (Dali::Vector4 *)jarg2;
8255   if (!arg2) {
8256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8257     return 0;
8258   }
8259   {
8260     try {
8261       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8262     } catch (std::out_of_range& e) {
8263       {
8264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8265       };
8266     } catch (std::exception& e) {
8267       {
8268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8269       };
8270     } catch (Dali::DaliException e) {
8271       {
8272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8273       };
8274     } catch (...) {
8275       {
8276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8277       };
8278     }
8279   }
8280
8281   jresult = result;
8282   return jresult;
8283 }
8284
8285
8286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8287   float jresult ;
8288   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8289   Dali::Vector4 *arg2 = 0 ;
8290   float result;
8291
8292   arg1 = (Dali::Vector4 *)jarg1;
8293   arg2 = (Dali::Vector4 *)jarg2;
8294   if (!arg2) {
8295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8296     return 0;
8297   }
8298   {
8299     try {
8300       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8301     } catch (std::out_of_range& e) {
8302       {
8303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8304       };
8305     } catch (std::exception& e) {
8306       {
8307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8308       };
8309     } catch (Dali::DaliException e) {
8310       {
8311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8312       };
8313     } catch (...) {
8314       {
8315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8316       };
8317     }
8318   }
8319
8320   jresult = result;
8321   return jresult;
8322 }
8323
8324
8325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8326   void * jresult ;
8327   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8328   Dali::Vector4 *arg2 = 0 ;
8329   Dali::Vector4 result;
8330
8331   arg1 = (Dali::Vector4 *)jarg1;
8332   arg2 = (Dali::Vector4 *)jarg2;
8333   if (!arg2) {
8334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8335     return 0;
8336   }
8337   {
8338     try {
8339       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8340     } catch (std::out_of_range& e) {
8341       {
8342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8343       };
8344     } catch (std::exception& e) {
8345       {
8346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8347       };
8348     } catch (Dali::DaliException e) {
8349       {
8350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8351       };
8352     } catch (...) {
8353       {
8354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8355       };
8356     }
8357   }
8358
8359   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8360   return jresult;
8361 }
8362
8363
8364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8365   float jresult ;
8366   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8367   float result;
8368
8369   arg1 = (Dali::Vector4 *)jarg1;
8370   {
8371     try {
8372       result = (float)((Dali::Vector4 const *)arg1)->Length();
8373     } catch (std::out_of_range& e) {
8374       {
8375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8376       };
8377     } catch (std::exception& e) {
8378       {
8379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8380       };
8381     } catch (Dali::DaliException e) {
8382       {
8383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8384       };
8385     } catch (...) {
8386       {
8387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8388       };
8389     }
8390   }
8391
8392   jresult = result;
8393   return jresult;
8394 }
8395
8396
8397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8398   float jresult ;
8399   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8400   float result;
8401
8402   arg1 = (Dali::Vector4 *)jarg1;
8403   {
8404     try {
8405       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8406     } catch (std::out_of_range& e) {
8407       {
8408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (std::exception& e) {
8411       {
8412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8413       };
8414     } catch (Dali::DaliException e) {
8415       {
8416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8417       };
8418     } catch (...) {
8419       {
8420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8421       };
8422     }
8423   }
8424
8425   jresult = result;
8426   return jresult;
8427 }
8428
8429
8430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8431   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8432
8433   arg1 = (Dali::Vector4 *)jarg1;
8434   {
8435     try {
8436       (arg1)->Normalize();
8437     } catch (std::out_of_range& e) {
8438       {
8439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8440       };
8441     } catch (std::exception& e) {
8442       {
8443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8444       };
8445     } catch (Dali::DaliException e) {
8446       {
8447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8448       };
8449     } catch (...) {
8450       {
8451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8452       };
8453     }
8454   }
8455
8456 }
8457
8458
8459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8460   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8461   Dali::Vector4 *arg2 = 0 ;
8462   Dali::Vector4 *arg3 = 0 ;
8463
8464   arg1 = (Dali::Vector4 *)jarg1;
8465   arg2 = (Dali::Vector4 *)jarg2;
8466   if (!arg2) {
8467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8468     return ;
8469   }
8470   arg3 = (Dali::Vector4 *)jarg3;
8471   if (!arg3) {
8472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8473     return ;
8474   }
8475   {
8476     try {
8477       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8478     } catch (std::out_of_range& e) {
8479       {
8480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8481       };
8482     } catch (std::exception& e) {
8483       {
8484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8485       };
8486     } catch (Dali::DaliException e) {
8487       {
8488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8489       };
8490     } catch (...) {
8491       {
8492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8493       };
8494     }
8495   }
8496
8497 }
8498
8499
8500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8501   void * jresult ;
8502   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8503   float *result = 0 ;
8504
8505   arg1 = (Dali::Vector4 *)jarg1;
8506   {
8507     try {
8508       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8509     } catch (std::out_of_range& e) {
8510       {
8511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8512       };
8513     } catch (std::exception& e) {
8514       {
8515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8516       };
8517     } catch (Dali::DaliException e) {
8518       {
8519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8520       };
8521     } catch (...) {
8522       {
8523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8524       };
8525     }
8526   }
8527
8528   jresult = (void *)result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8535   float arg2 ;
8536
8537   arg1 = (Dali::Vector4 *)jarg1;
8538   arg2 = (float)jarg2;
8539   if (arg1) (arg1)->x = arg2;
8540 }
8541
8542
8543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8544   float jresult ;
8545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8546   float result;
8547
8548   arg1 = (Dali::Vector4 *)jarg1;
8549   result = (float) ((arg1)->x);
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8556   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8557   float arg2 ;
8558
8559   arg1 = (Dali::Vector4 *)jarg1;
8560   arg2 = (float)jarg2;
8561   if (arg1) (arg1)->r = arg2;
8562 }
8563
8564
8565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8566   float jresult ;
8567   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8568   float result;
8569
8570   arg1 = (Dali::Vector4 *)jarg1;
8571   result = (float) ((arg1)->r);
8572   jresult = result;
8573   return jresult;
8574 }
8575
8576
8577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8579   float arg2 ;
8580
8581   arg1 = (Dali::Vector4 *)jarg1;
8582   arg2 = (float)jarg2;
8583   if (arg1) (arg1)->s = arg2;
8584 }
8585
8586
8587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8588   float jresult ;
8589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8590   float result;
8591
8592   arg1 = (Dali::Vector4 *)jarg1;
8593   result = (float) ((arg1)->s);
8594   jresult = result;
8595   return jresult;
8596 }
8597
8598
8599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8600   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8601   float arg2 ;
8602
8603   arg1 = (Dali::Vector4 *)jarg1;
8604   arg2 = (float)jarg2;
8605   if (arg1) (arg1)->y = arg2;
8606 }
8607
8608
8609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8610   float jresult ;
8611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8612   float result;
8613
8614   arg1 = (Dali::Vector4 *)jarg1;
8615   result = (float) ((arg1)->y);
8616   jresult = result;
8617   return jresult;
8618 }
8619
8620
8621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8622   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8623   float arg2 ;
8624
8625   arg1 = (Dali::Vector4 *)jarg1;
8626   arg2 = (float)jarg2;
8627   if (arg1) (arg1)->g = arg2;
8628 }
8629
8630
8631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8632   float jresult ;
8633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8634   float result;
8635
8636   arg1 = (Dali::Vector4 *)jarg1;
8637   result = (float) ((arg1)->g);
8638   jresult = result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8645   float arg2 ;
8646
8647   arg1 = (Dali::Vector4 *)jarg1;
8648   arg2 = (float)jarg2;
8649   if (arg1) (arg1)->t = arg2;
8650 }
8651
8652
8653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8654   float jresult ;
8655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8656   float result;
8657
8658   arg1 = (Dali::Vector4 *)jarg1;
8659   result = (float) ((arg1)->t);
8660   jresult = result;
8661   return jresult;
8662 }
8663
8664
8665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8666   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8667   float arg2 ;
8668
8669   arg1 = (Dali::Vector4 *)jarg1;
8670   arg2 = (float)jarg2;
8671   if (arg1) (arg1)->z = arg2;
8672 }
8673
8674
8675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8676   float jresult ;
8677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8678   float result;
8679
8680   arg1 = (Dali::Vector4 *)jarg1;
8681   result = (float) ((arg1)->z);
8682   jresult = result;
8683   return jresult;
8684 }
8685
8686
8687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8689   float arg2 ;
8690
8691   arg1 = (Dali::Vector4 *)jarg1;
8692   arg2 = (float)jarg2;
8693   if (arg1) (arg1)->b = arg2;
8694 }
8695
8696
8697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8698   float jresult ;
8699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8700   float result;
8701
8702   arg1 = (Dali::Vector4 *)jarg1;
8703   result = (float) ((arg1)->b);
8704   jresult = result;
8705   return jresult;
8706 }
8707
8708
8709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8711   float arg2 ;
8712
8713   arg1 = (Dali::Vector4 *)jarg1;
8714   arg2 = (float)jarg2;
8715   if (arg1) (arg1)->p = arg2;
8716 }
8717
8718
8719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8720   float jresult ;
8721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8722   float result;
8723
8724   arg1 = (Dali::Vector4 *)jarg1;
8725   result = (float) ((arg1)->p);
8726   jresult = result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8733   float arg2 ;
8734
8735   arg1 = (Dali::Vector4 *)jarg1;
8736   arg2 = (float)jarg2;
8737   if (arg1) (arg1)->w = arg2;
8738 }
8739
8740
8741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8742   float jresult ;
8743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8744   float result;
8745
8746   arg1 = (Dali::Vector4 *)jarg1;
8747   result = (float) ((arg1)->w);
8748   jresult = result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8755   float arg2 ;
8756
8757   arg1 = (Dali::Vector4 *)jarg1;
8758   arg2 = (float)jarg2;
8759   if (arg1) (arg1)->a = arg2;
8760 }
8761
8762
8763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8764   float jresult ;
8765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8766   float result;
8767
8768   arg1 = (Dali::Vector4 *)jarg1;
8769   result = (float) ((arg1)->a);
8770   jresult = result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8777   float arg2 ;
8778
8779   arg1 = (Dali::Vector4 *)jarg1;
8780   arg2 = (float)jarg2;
8781   if (arg1) (arg1)->q = arg2;
8782 }
8783
8784
8785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8786   float jresult ;
8787   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8788   float result;
8789
8790   arg1 = (Dali::Vector4 *)jarg1;
8791   result = (float) ((arg1)->q);
8792   jresult = result;
8793   return jresult;
8794 }
8795
8796
8797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8799
8800   arg1 = (Dali::Vector4 *)jarg1;
8801   {
8802     try {
8803       delete arg1;
8804     } catch (std::out_of_range& e) {
8805       {
8806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8807       };
8808     } catch (std::exception& e) {
8809       {
8810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8811       };
8812     } catch (Dali::DaliException e) {
8813       {
8814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8815       };
8816     } catch (...) {
8817       {
8818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8819       };
8820     }
8821   }
8822
8823 }
8824
8825
8826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8827   void * jresult ;
8828   Dali::Vector4 *arg1 = 0 ;
8829   Dali::Vector4 *arg2 = 0 ;
8830   Dali::Vector4 result;
8831
8832   arg1 = (Dali::Vector4 *)jarg1;
8833   if (!arg1) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8835     return 0;
8836   }
8837   arg2 = (Dali::Vector4 *)jarg2;
8838   if (!arg2) {
8839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8840     return 0;
8841   }
8842   {
8843     try {
8844       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8845     } catch (std::out_of_range& e) {
8846       {
8847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8848       };
8849     } catch (std::exception& e) {
8850       {
8851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8852       };
8853     } catch (Dali::DaliException e) {
8854       {
8855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8856       };
8857     } catch (...) {
8858       {
8859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8860       };
8861     }
8862   }
8863
8864   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8865   return jresult;
8866 }
8867
8868
8869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8870   void * jresult ;
8871   Dali::Vector4 *arg1 = 0 ;
8872   Dali::Vector4 *arg2 = 0 ;
8873   Dali::Vector4 result;
8874
8875   arg1 = (Dali::Vector4 *)jarg1;
8876   if (!arg1) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   arg2 = (Dali::Vector4 *)jarg2;
8881   if (!arg2) {
8882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8883     return 0;
8884   }
8885   {
8886     try {
8887       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8888     } catch (std::out_of_range& e) {
8889       {
8890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8891       };
8892     } catch (std::exception& e) {
8893       {
8894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (Dali::DaliException e) {
8897       {
8898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906
8907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8908   return jresult;
8909 }
8910
8911
8912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8913   void * jresult ;
8914   Dali::Vector4 *arg1 = 0 ;
8915   float *arg2 = 0 ;
8916   float *arg3 = 0 ;
8917   float temp2 ;
8918   float temp3 ;
8919   Dali::Vector4 result;
8920
8921   arg1 = (Dali::Vector4 *)jarg1;
8922   if (!arg1) {
8923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8924     return 0;
8925   }
8926   temp2 = (float)jarg2;
8927   arg2 = &temp2;
8928   temp3 = (float)jarg3;
8929   arg3 = &temp3;
8930   {
8931     try {
8932       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (Dali::DaliException e) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8944       };
8945     } catch (...) {
8946       {
8947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8948       };
8949     }
8950   }
8951
8952   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8953   return jresult;
8954 }
8955
8956
8957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8958   void * jresult ;
8959   Dali::Uint16Pair *result = 0 ;
8960
8961   {
8962     try {
8963       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8964     } catch (std::out_of_range& e) {
8965       {
8966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (std::exception& e) {
8969       {
8970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8971       };
8972     } catch (Dali::DaliException e) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8975       };
8976     } catch (...) {
8977       {
8978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8979       };
8980     }
8981   }
8982
8983   jresult = (void *)result;
8984   return jresult;
8985 }
8986
8987
8988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8989   void * jresult ;
8990   uint32_t arg1 ;
8991   uint32_t arg2 ;
8992   Dali::Uint16Pair *result = 0 ;
8993
8994   arg1 = (uint32_t)jarg1;
8995   arg2 = (uint32_t)jarg2;
8996   {
8997     try {
8998       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8999     } catch (std::out_of_range& e) {
9000       {
9001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9002       };
9003     } catch (std::exception& e) {
9004       {
9005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9006       };
9007     } catch (Dali::DaliException e) {
9008       {
9009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9010       };
9011     } catch (...) {
9012       {
9013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9014       };
9015     }
9016   }
9017
9018   jresult = (void *)result;
9019   return jresult;
9020 }
9021
9022
9023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9024   void * jresult ;
9025   Dali::Uint16Pair *arg1 = 0 ;
9026   Dali::Uint16Pair *result = 0 ;
9027
9028   arg1 = (Dali::Uint16Pair *)jarg1;
9029   if (!arg1) {
9030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9031     return 0;
9032   }
9033   {
9034     try {
9035       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9036     } catch (std::out_of_range& e) {
9037       {
9038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9039       };
9040     } catch (std::exception& e) {
9041       {
9042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9043       };
9044     } catch (Dali::DaliException e) {
9045       {
9046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9047       };
9048     } catch (...) {
9049       {
9050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9051       };
9052     }
9053   }
9054
9055   jresult = (void *)result;
9056   return jresult;
9057 }
9058
9059
9060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9061   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9062   uint16_t arg2 ;
9063
9064   arg1 = (Dali::Uint16Pair *)jarg1;
9065   arg2 = (uint16_t)jarg2;
9066   {
9067     try {
9068       (arg1)->SetWidth(arg2);
9069     } catch (std::out_of_range& e) {
9070       {
9071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9072       };
9073     } catch (std::exception& e) {
9074       {
9075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9076       };
9077     } catch (Dali::DaliException e) {
9078       {
9079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9080       };
9081     } catch (...) {
9082       {
9083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9084       };
9085     }
9086   }
9087
9088 }
9089
9090
9091 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9092   unsigned short jresult ;
9093   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9094   uint16_t result;
9095
9096   arg1 = (Dali::Uint16Pair *)jarg1;
9097   {
9098     try {
9099       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9100     } catch (std::out_of_range& e) {
9101       {
9102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9103       };
9104     } catch (std::exception& e) {
9105       {
9106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9107       };
9108     } catch (Dali::DaliException e) {
9109       {
9110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9111       };
9112     } catch (...) {
9113       {
9114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9115       };
9116     }
9117   }
9118
9119   jresult = result;
9120   return jresult;
9121 }
9122
9123
9124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9125   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9126   uint16_t arg2 ;
9127
9128   arg1 = (Dali::Uint16Pair *)jarg1;
9129   arg2 = (uint16_t)jarg2;
9130   {
9131     try {
9132       (arg1)->SetHeight(arg2);
9133     } catch (std::out_of_range& e) {
9134       {
9135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9136       };
9137     } catch (std::exception& e) {
9138       {
9139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9140       };
9141     } catch (Dali::DaliException e) {
9142       {
9143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9144       };
9145     } catch (...) {
9146       {
9147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9148       };
9149     }
9150   }
9151
9152 }
9153
9154
9155 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9156   unsigned short jresult ;
9157   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9158   uint16_t result;
9159
9160   arg1 = (Dali::Uint16Pair *)jarg1;
9161   {
9162     try {
9163       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9164     } catch (std::out_of_range& e) {
9165       {
9166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9167       };
9168     } catch (std::exception& e) {
9169       {
9170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9171       };
9172     } catch (Dali::DaliException e) {
9173       {
9174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9175       };
9176     } catch (...) {
9177       {
9178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9179       };
9180     }
9181   }
9182
9183   jresult = result;
9184   return jresult;
9185 }
9186
9187
9188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9189   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9190   uint16_t arg2 ;
9191
9192   arg1 = (Dali::Uint16Pair *)jarg1;
9193   arg2 = (uint16_t)jarg2;
9194   {
9195     try {
9196       (arg1)->SetX(arg2);
9197     } catch (std::out_of_range& e) {
9198       {
9199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9200       };
9201     } catch (std::exception& e) {
9202       {
9203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9204       };
9205     } catch (Dali::DaliException e) {
9206       {
9207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9208       };
9209     } catch (...) {
9210       {
9211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9212       };
9213     }
9214   }
9215
9216 }
9217
9218
9219 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9220   unsigned short jresult ;
9221   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9222   uint16_t result;
9223
9224   arg1 = (Dali::Uint16Pair *)jarg1;
9225   {
9226     try {
9227       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9228     } catch (std::out_of_range& e) {
9229       {
9230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9231       };
9232     } catch (std::exception& e) {
9233       {
9234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9235       };
9236     } catch (Dali::DaliException e) {
9237       {
9238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9239       };
9240     } catch (...) {
9241       {
9242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9243       };
9244     }
9245   }
9246
9247   jresult = result;
9248   return jresult;
9249 }
9250
9251
9252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9253   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9254   uint16_t arg2 ;
9255
9256   arg1 = (Dali::Uint16Pair *)jarg1;
9257   arg2 = (uint16_t)jarg2;
9258   {
9259     try {
9260       (arg1)->SetY(arg2);
9261     } catch (std::out_of_range& e) {
9262       {
9263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9264       };
9265     } catch (std::exception& e) {
9266       {
9267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9268       };
9269     } catch (Dali::DaliException e) {
9270       {
9271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9272       };
9273     } catch (...) {
9274       {
9275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9276       };
9277     }
9278   }
9279
9280 }
9281
9282
9283 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9284   unsigned short jresult ;
9285   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9286   uint16_t result;
9287
9288   arg1 = (Dali::Uint16Pair *)jarg1;
9289   {
9290     try {
9291       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9292     } catch (std::out_of_range& e) {
9293       {
9294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9295       };
9296     } catch (std::exception& e) {
9297       {
9298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9299       };
9300     } catch (Dali::DaliException e) {
9301       {
9302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9303       };
9304     } catch (...) {
9305       {
9306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9307       };
9308     }
9309   }
9310
9311   jresult = result;
9312   return jresult;
9313 }
9314
9315
9316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9317   void * jresult ;
9318   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9319   Dali::Uint16Pair *arg2 = 0 ;
9320   Dali::Uint16Pair *result = 0 ;
9321
9322   arg1 = (Dali::Uint16Pair *)jarg1;
9323   arg2 = (Dali::Uint16Pair *)jarg2;
9324   if (!arg2) {
9325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9326     return 0;
9327   }
9328   {
9329     try {
9330       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9331     } catch (std::out_of_range& e) {
9332       {
9333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9334       };
9335     } catch (std::exception& e) {
9336       {
9337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9338       };
9339     } catch (Dali::DaliException e) {
9340       {
9341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9342       };
9343     } catch (...) {
9344       {
9345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9346       };
9347     }
9348   }
9349
9350   jresult = (void *)result;
9351   return jresult;
9352 }
9353
9354
9355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9356   unsigned int jresult ;
9357   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9358   Dali::Uint16Pair *arg2 = 0 ;
9359   bool result;
9360
9361   arg1 = (Dali::Uint16Pair *)jarg1;
9362   arg2 = (Dali::Uint16Pair *)jarg2;
9363   if (!arg2) {
9364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9365     return 0;
9366   }
9367   {
9368     try {
9369       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9370     } catch (std::out_of_range& e) {
9371       {
9372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9373       };
9374     } catch (std::exception& e) {
9375       {
9376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9377       };
9378     } catch (Dali::DaliException e) {
9379       {
9380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9381       };
9382     } catch (...) {
9383       {
9384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9385       };
9386     }
9387   }
9388
9389   jresult = result;
9390   return jresult;
9391 }
9392
9393
9394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9395   unsigned int jresult ;
9396   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9397   Dali::Uint16Pair *arg2 = 0 ;
9398   bool result;
9399
9400   arg1 = (Dali::Uint16Pair *)jarg1;
9401   arg2 = (Dali::Uint16Pair *)jarg2;
9402   if (!arg2) {
9403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9404     return 0;
9405   }
9406   {
9407     try {
9408       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9409     } catch (std::out_of_range& e) {
9410       {
9411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9412       };
9413     } catch (std::exception& e) {
9414       {
9415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9416       };
9417     } catch (Dali::DaliException e) {
9418       {
9419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9420       };
9421     } catch (...) {
9422       {
9423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9424       };
9425     }
9426   }
9427
9428   jresult = result;
9429   return jresult;
9430 }
9431
9432
9433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9434   unsigned int jresult ;
9435   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9436   Dali::Uint16Pair *arg2 = 0 ;
9437   bool result;
9438
9439   arg1 = (Dali::Uint16Pair *)jarg1;
9440   arg2 = (Dali::Uint16Pair *)jarg2;
9441   if (!arg2) {
9442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9443     return 0;
9444   }
9445   {
9446     try {
9447       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9448     } catch (std::out_of_range& e) {
9449       {
9450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9451       };
9452     } catch (std::exception& e) {
9453       {
9454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9455       };
9456     } catch (Dali::DaliException e) {
9457       {
9458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9459       };
9460     } catch (...) {
9461       {
9462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9463       };
9464     }
9465   }
9466
9467   jresult = result;
9468   return jresult;
9469 }
9470
9471
9472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9473   unsigned int jresult ;
9474   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9475   Dali::Uint16Pair *arg2 = 0 ;
9476   bool result;
9477
9478   arg1 = (Dali::Uint16Pair *)jarg1;
9479   arg2 = (Dali::Uint16Pair *)jarg2;
9480   if (!arg2) {
9481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9482     return 0;
9483   }
9484   {
9485     try {
9486       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9487     } catch (std::out_of_range& e) {
9488       {
9489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9490       };
9491     } catch (std::exception& e) {
9492       {
9493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9494       };
9495     } catch (Dali::DaliException e) {
9496       {
9497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9498       };
9499     } catch (...) {
9500       {
9501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9502       };
9503     }
9504   }
9505
9506   jresult = result;
9507   return jresult;
9508 }
9509
9510
9511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9512   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9513
9514   arg1 = (Dali::Uint16Pair *)jarg1;
9515   {
9516     try {
9517       delete arg1;
9518     } catch (std::out_of_range& e) {
9519       {
9520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9521       };
9522     } catch (std::exception& e) {
9523       {
9524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9525       };
9526     } catch (Dali::DaliException e) {
9527       {
9528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9529       };
9530     } catch (...) {
9531       {
9532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9533       };
9534     }
9535   }
9536
9537 }
9538
9539
9540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9541   void * jresult ;
9542   Dali::Degree *result = 0 ;
9543
9544   {
9545     try {
9546       result = (Dali::Degree *)new Dali::Degree();
9547     } catch (std::out_of_range& e) {
9548       {
9549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9550       };
9551     } catch (std::exception& e) {
9552       {
9553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9554       };
9555     } catch (Dali::DaliException e) {
9556       {
9557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9558       };
9559     } catch (...) {
9560       {
9561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9562       };
9563     }
9564   }
9565
9566   jresult = (void *)result;
9567   return jresult;
9568 }
9569
9570
9571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9572   void * jresult ;
9573   float arg1 ;
9574   Dali::Degree *result = 0 ;
9575
9576   arg1 = (float)jarg1;
9577   {
9578     try {
9579       result = (Dali::Degree *)new Dali::Degree(arg1);
9580     } catch (std::out_of_range& e) {
9581       {
9582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9583       };
9584     } catch (std::exception& e) {
9585       {
9586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9587       };
9588     } catch (Dali::DaliException e) {
9589       {
9590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9591       };
9592     } catch (...) {
9593       {
9594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9595       };
9596     }
9597   }
9598
9599   jresult = (void *)result;
9600   return jresult;
9601 }
9602
9603
9604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9605   void * jresult ;
9606   Dali::Radian arg1 ;
9607   Dali::Radian *argp1 ;
9608   Dali::Degree *result = 0 ;
9609
9610   argp1 = (Dali::Radian *)jarg1;
9611   if (!argp1) {
9612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9613     return 0;
9614   }
9615   arg1 = *argp1;
9616   {
9617     try {
9618       result = (Dali::Degree *)new Dali::Degree(arg1);
9619     } catch (std::out_of_range& e) {
9620       {
9621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (std::exception& e) {
9624       {
9625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9626       };
9627     } catch (Dali::DaliException e) {
9628       {
9629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9630       };
9631     } catch (...) {
9632       {
9633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9634       };
9635     }
9636   }
9637
9638   jresult = (void *)result;
9639   return jresult;
9640 }
9641
9642
9643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9644   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9645   float arg2 ;
9646
9647   arg1 = (Dali::Degree *)jarg1;
9648   arg2 = (float)jarg2;
9649   if (arg1) (arg1)->degree = arg2;
9650 }
9651
9652
9653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9654   float jresult ;
9655   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9656   float result;
9657
9658   arg1 = (Dali::Degree *)jarg1;
9659   result = (float) ((arg1)->degree);
9660   jresult = result;
9661   return jresult;
9662 }
9663
9664
9665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9666   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9667
9668   arg1 = (Dali::Degree *)jarg1;
9669   {
9670     try {
9671       delete arg1;
9672     } catch (std::out_of_range& e) {
9673       {
9674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9675       };
9676     } catch (std::exception& e) {
9677       {
9678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9679       };
9680     } catch (Dali::DaliException e) {
9681       {
9682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9683       };
9684     } catch (...) {
9685       {
9686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9687       };
9688     }
9689   }
9690
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_360;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_315;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_270;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_225;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_180;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_135;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_120;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_90;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_60;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9785   void * jresult ;
9786   Dali::Radian *result = 0 ;
9787
9788   result = (Dali::Radian *)&Dali::ANGLE_45;
9789   jresult = (void *)result;
9790   return jresult;
9791 }
9792
9793
9794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9795   void * jresult ;
9796   Dali::Radian *result = 0 ;
9797
9798   result = (Dali::Radian *)&Dali::ANGLE_30;
9799   jresult = (void *)result;
9800   return jresult;
9801 }
9802
9803
9804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9805   void * jresult ;
9806   Dali::Radian *result = 0 ;
9807
9808   result = (Dali::Radian *)&Dali::ANGLE_0;
9809   jresult = (void *)result;
9810   return jresult;
9811 }
9812
9813
9814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9815   unsigned int jresult ;
9816   Dali::Degree *arg1 = 0 ;
9817   Dali::Degree *arg2 = 0 ;
9818   bool result;
9819
9820   arg1 = (Dali::Degree *)jarg1;
9821   if (!arg1) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9823     return 0;
9824   }
9825   arg2 = (Dali::Degree *)jarg2;
9826   if (!arg2) {
9827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9828     return 0;
9829   }
9830   {
9831     try {
9832       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9833     } catch (std::out_of_range& e) {
9834       {
9835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9836       };
9837     } catch (std::exception& e) {
9838       {
9839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (Dali::DaliException e) {
9842       {
9843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9844       };
9845     } catch (...) {
9846       {
9847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9848       };
9849     }
9850   }
9851
9852   jresult = result;
9853   return jresult;
9854 }
9855
9856
9857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9858   unsigned int jresult ;
9859   Dali::Degree *arg1 = 0 ;
9860   Dali::Degree *arg2 = 0 ;
9861   bool result;
9862
9863   arg1 = (Dali::Degree *)jarg1;
9864   if (!arg1) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9866     return 0;
9867   }
9868   arg2 = (Dali::Degree *)jarg2;
9869   if (!arg2) {
9870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9871     return 0;
9872   }
9873   {
9874     try {
9875       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9876     } catch (std::out_of_range& e) {
9877       {
9878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9879       };
9880     } catch (std::exception& e) {
9881       {
9882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9883       };
9884     } catch (Dali::DaliException e) {
9885       {
9886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9887       };
9888     } catch (...) {
9889       {
9890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9891       };
9892     }
9893   }
9894
9895   jresult = result;
9896   return jresult;
9897 }
9898
9899
9900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9901   void * jresult ;
9902   Dali::Degree arg1 ;
9903   float arg2 ;
9904   float arg3 ;
9905   Dali::Degree *argp1 ;
9906   Dali::Degree result;
9907
9908   argp1 = (Dali::Degree *)jarg1;
9909   if (!argp1) {
9910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9911     return 0;
9912   }
9913   arg1 = *argp1;
9914   arg2 = (float)jarg2;
9915   arg3 = (float)jarg3;
9916   {
9917     try {
9918       result = Dali::Clamp(arg1,arg2,arg3);
9919     } catch (std::out_of_range& e) {
9920       {
9921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9922       };
9923     } catch (std::exception& e) {
9924       {
9925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9926       };
9927     } catch (Dali::DaliException e) {
9928       {
9929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9930       };
9931     } catch (...) {
9932       {
9933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9934       };
9935     }
9936   }
9937
9938   jresult = new Dali::Degree((const Dali::Degree &)result);
9939   return jresult;
9940 }
9941
9942
9943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9944   void * jresult ;
9945   Dali::Radian *result = 0 ;
9946
9947   {
9948     try {
9949       result = (Dali::Radian *)new Dali::Radian();
9950     } catch (std::out_of_range& e) {
9951       {
9952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9953       };
9954     } catch (std::exception& e) {
9955       {
9956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9957       };
9958     } catch (Dali::DaliException e) {
9959       {
9960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9961       };
9962     } catch (...) {
9963       {
9964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9965       };
9966     }
9967   }
9968
9969   jresult = (void *)result;
9970   return jresult;
9971 }
9972
9973
9974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9975   void * jresult ;
9976   float arg1 ;
9977   Dali::Radian *result = 0 ;
9978
9979   arg1 = (float)jarg1;
9980   {
9981     try {
9982       result = (Dali::Radian *)new Dali::Radian(arg1);
9983     } catch (std::out_of_range& e) {
9984       {
9985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9986       };
9987     } catch (std::exception& e) {
9988       {
9989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9990       };
9991     } catch (Dali::DaliException e) {
9992       {
9993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9994       };
9995     } catch (...) {
9996       {
9997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9998       };
9999     }
10000   }
10001
10002   jresult = (void *)result;
10003   return jresult;
10004 }
10005
10006
10007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10008   void * jresult ;
10009   Dali::Degree arg1 ;
10010   Dali::Degree *argp1 ;
10011   Dali::Radian *result = 0 ;
10012
10013   argp1 = (Dali::Degree *)jarg1;
10014   if (!argp1) {
10015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10016     return 0;
10017   }
10018   arg1 = *argp1;
10019   {
10020     try {
10021       result = (Dali::Radian *)new Dali::Radian(arg1);
10022     } catch (std::out_of_range& e) {
10023       {
10024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10025       };
10026     } catch (std::exception& e) {
10027       {
10028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10029       };
10030     } catch (Dali::DaliException e) {
10031       {
10032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10033       };
10034     } catch (...) {
10035       {
10036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10037       };
10038     }
10039   }
10040
10041   jresult = (void *)result;
10042   return jresult;
10043 }
10044
10045
10046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10047   void * jresult ;
10048   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10049   float arg2 ;
10050   Dali::Radian *result = 0 ;
10051
10052   arg1 = (Dali::Radian *)jarg1;
10053   arg2 = (float)jarg2;
10054   {
10055     try {
10056       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10057     } catch (std::out_of_range& e) {
10058       {
10059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10060       };
10061     } catch (std::exception& e) {
10062       {
10063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10064       };
10065     } catch (Dali::DaliException e) {
10066       {
10067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10068       };
10069     } catch (...) {
10070       {
10071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10072       };
10073     }
10074   }
10075
10076   jresult = (void *)result;
10077   return jresult;
10078 }
10079
10080
10081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10082   void * jresult ;
10083   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10084   Dali::Degree arg2 ;
10085   Dali::Degree *argp2 ;
10086   Dali::Radian *result = 0 ;
10087
10088   arg1 = (Dali::Radian *)jarg1;
10089   argp2 = (Dali::Degree *)jarg2;
10090   if (!argp2) {
10091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10092     return 0;
10093   }
10094   arg2 = *argp2;
10095   {
10096     try {
10097       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10098     } catch (std::out_of_range& e) {
10099       {
10100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10101       };
10102     } catch (std::exception& e) {
10103       {
10104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10105       };
10106     } catch (Dali::DaliException e) {
10107       {
10108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10109       };
10110     } catch (...) {
10111       {
10112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10113       };
10114     }
10115   }
10116
10117   jresult = (void *)result;
10118   return jresult;
10119 }
10120
10121
10122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10123   float jresult ;
10124   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10125   float result;
10126
10127   arg1 = (Dali::Radian *)jarg1;
10128   {
10129     try {
10130       result = (float)((Dali::Radian const *)arg1)->operator float();
10131     } catch (std::out_of_range& e) {
10132       {
10133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10134       };
10135     } catch (std::exception& e) {
10136       {
10137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10138       };
10139     } catch (Dali::DaliException e) {
10140       {
10141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10142       };
10143     } catch (...) {
10144       {
10145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10146       };
10147     }
10148   }
10149
10150   jresult = result;
10151   return jresult;
10152 }
10153
10154
10155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10156   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10157   float arg2 ;
10158
10159   arg1 = (Dali::Radian *)jarg1;
10160   arg2 = (float)jarg2;
10161   if (arg1) (arg1)->radian = arg2;
10162 }
10163
10164
10165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10166   float jresult ;
10167   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10168   float result;
10169
10170   arg1 = (Dali::Radian *)jarg1;
10171   result = (float) ((arg1)->radian);
10172   jresult = result;
10173   return jresult;
10174 }
10175
10176
10177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10178   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10179
10180   arg1 = (Dali::Radian *)jarg1;
10181   {
10182     try {
10183       delete arg1;
10184     } catch (std::out_of_range& e) {
10185       {
10186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10187       };
10188     } catch (std::exception& e) {
10189       {
10190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10191       };
10192     } catch (Dali::DaliException e) {
10193       {
10194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10195       };
10196     } catch (...) {
10197       {
10198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10199       };
10200     }
10201   }
10202
10203 }
10204
10205
10206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10207   unsigned int jresult ;
10208   Dali::Radian arg1 ;
10209   Dali::Radian arg2 ;
10210   Dali::Radian *argp1 ;
10211   Dali::Radian *argp2 ;
10212   bool result;
10213
10214   argp1 = (Dali::Radian *)jarg1;
10215   if (!argp1) {
10216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10217     return 0;
10218   }
10219   arg1 = *argp1;
10220   argp2 = (Dali::Radian *)jarg2;
10221   if (!argp2) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10223     return 0;
10224   }
10225   arg2 = *argp2;
10226   {
10227     try {
10228       result = (bool)Dali::operator ==(arg1,arg2);
10229     } catch (std::out_of_range& e) {
10230       {
10231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (std::exception& e) {
10234       {
10235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10236       };
10237     } catch (Dali::DaliException e) {
10238       {
10239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10240       };
10241     } catch (...) {
10242       {
10243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10244       };
10245     }
10246   }
10247
10248   jresult = result;
10249   return jresult;
10250 }
10251
10252
10253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10254   unsigned int jresult ;
10255   Dali::Radian arg1 ;
10256   Dali::Radian arg2 ;
10257   Dali::Radian *argp1 ;
10258   Dali::Radian *argp2 ;
10259   bool result;
10260
10261   argp1 = (Dali::Radian *)jarg1;
10262   if (!argp1) {
10263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10264     return 0;
10265   }
10266   arg1 = *argp1;
10267   argp2 = (Dali::Radian *)jarg2;
10268   if (!argp2) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10270     return 0;
10271   }
10272   arg2 = *argp2;
10273   {
10274     try {
10275       result = (bool)Dali::operator !=(arg1,arg2);
10276     } catch (std::out_of_range& e) {
10277       {
10278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10279       };
10280     } catch (std::exception& e) {
10281       {
10282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10283       };
10284     } catch (Dali::DaliException e) {
10285       {
10286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10287       };
10288     } catch (...) {
10289       {
10290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10291       };
10292     }
10293   }
10294
10295   jresult = result;
10296   return jresult;
10297 }
10298
10299
10300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10301   unsigned int jresult ;
10302   Dali::Radian arg1 ;
10303   Dali::Degree arg2 ;
10304   Dali::Radian *argp1 ;
10305   Dali::Degree *argp2 ;
10306   bool result;
10307
10308   argp1 = (Dali::Radian *)jarg1;
10309   if (!argp1) {
10310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10311     return 0;
10312   }
10313   arg1 = *argp1;
10314   argp2 = (Dali::Degree *)jarg2;
10315   if (!argp2) {
10316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10317     return 0;
10318   }
10319   arg2 = *argp2;
10320   {
10321     try {
10322       result = (bool)Dali::operator ==(arg1,arg2);
10323     } catch (std::out_of_range& e) {
10324       {
10325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10326       };
10327     } catch (std::exception& e) {
10328       {
10329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (Dali::DaliException e) {
10332       {
10333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10334       };
10335     } catch (...) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10338       };
10339     }
10340   }
10341
10342   jresult = result;
10343   return jresult;
10344 }
10345
10346
10347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10348   unsigned int jresult ;
10349   Dali::Radian arg1 ;
10350   Dali::Degree arg2 ;
10351   Dali::Radian *argp1 ;
10352   Dali::Degree *argp2 ;
10353   bool result;
10354
10355   argp1 = (Dali::Radian *)jarg1;
10356   if (!argp1) {
10357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10358     return 0;
10359   }
10360   arg1 = *argp1;
10361   argp2 = (Dali::Degree *)jarg2;
10362   if (!argp2) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10364     return 0;
10365   }
10366   arg2 = *argp2;
10367   {
10368     try {
10369       result = (bool)Dali::operator !=(arg1,arg2);
10370     } catch (std::out_of_range& e) {
10371       {
10372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10373       };
10374     } catch (std::exception& e) {
10375       {
10376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10377       };
10378     } catch (Dali::DaliException e) {
10379       {
10380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10381       };
10382     } catch (...) {
10383       {
10384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10385       };
10386     }
10387   }
10388
10389   jresult = result;
10390   return jresult;
10391 }
10392
10393
10394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10395   unsigned int jresult ;
10396   Dali::Degree arg1 ;
10397   Dali::Radian arg2 ;
10398   Dali::Degree *argp1 ;
10399   Dali::Radian *argp2 ;
10400   bool result;
10401
10402   argp1 = (Dali::Degree *)jarg1;
10403   if (!argp1) {
10404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10405     return 0;
10406   }
10407   arg1 = *argp1;
10408   argp2 = (Dali::Radian *)jarg2;
10409   if (!argp2) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10411     return 0;
10412   }
10413   arg2 = *argp2;
10414   {
10415     try {
10416       result = (bool)Dali::operator ==(arg1,arg2);
10417     } catch (std::out_of_range& e) {
10418       {
10419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10420       };
10421     } catch (std::exception& e) {
10422       {
10423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10424       };
10425     } catch (Dali::DaliException e) {
10426       {
10427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10428       };
10429     } catch (...) {
10430       {
10431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10432       };
10433     }
10434   }
10435
10436   jresult = result;
10437   return jresult;
10438 }
10439
10440
10441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10442   unsigned int jresult ;
10443   Dali::Degree arg1 ;
10444   Dali::Radian arg2 ;
10445   Dali::Degree *argp1 ;
10446   Dali::Radian *argp2 ;
10447   bool result;
10448
10449   argp1 = (Dali::Degree *)jarg1;
10450   if (!argp1) {
10451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10452     return 0;
10453   }
10454   arg1 = *argp1;
10455   argp2 = (Dali::Radian *)jarg2;
10456   if (!argp2) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10458     return 0;
10459   }
10460   arg2 = *argp2;
10461   {
10462     try {
10463       result = (bool)Dali::operator !=(arg1,arg2);
10464     } catch (std::out_of_range& e) {
10465       {
10466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10467       };
10468     } catch (std::exception& e) {
10469       {
10470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10471       };
10472     } catch (Dali::DaliException e) {
10473       {
10474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10475       };
10476     } catch (...) {
10477       {
10478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10479       };
10480     }
10481   }
10482
10483   jresult = result;
10484   return jresult;
10485 }
10486
10487
10488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10489   unsigned int jresult ;
10490   Dali::Radian arg1 ;
10491   Dali::Radian arg2 ;
10492   Dali::Radian *argp1 ;
10493   Dali::Radian *argp2 ;
10494   bool result;
10495
10496   argp1 = (Dali::Radian *)jarg1;
10497   if (!argp1) {
10498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10499     return 0;
10500   }
10501   arg1 = *argp1;
10502   argp2 = (Dali::Radian *)jarg2;
10503   if (!argp2) {
10504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10505     return 0;
10506   }
10507   arg2 = *argp2;
10508   {
10509     try {
10510       result = (bool)Dali::operator >(arg1,arg2);
10511     } catch (std::out_of_range& e) {
10512       {
10513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10514       };
10515     } catch (std::exception& e) {
10516       {
10517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10518       };
10519     } catch (Dali::DaliException e) {
10520       {
10521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10522       };
10523     } catch (...) {
10524       {
10525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10526       };
10527     }
10528   }
10529
10530   jresult = result;
10531   return jresult;
10532 }
10533
10534
10535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10536   unsigned int jresult ;
10537   Dali::Radian arg1 ;
10538   Dali::Degree arg2 ;
10539   Dali::Radian *argp1 ;
10540   Dali::Degree *argp2 ;
10541   bool result;
10542
10543   argp1 = (Dali::Radian *)jarg1;
10544   if (!argp1) {
10545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10546     return 0;
10547   }
10548   arg1 = *argp1;
10549   argp2 = (Dali::Degree *)jarg2;
10550   if (!argp2) {
10551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10552     return 0;
10553   }
10554   arg2 = *argp2;
10555   {
10556     try {
10557       result = (bool)Dali::operator >(arg1,arg2);
10558     } catch (std::out_of_range& e) {
10559       {
10560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10561       };
10562     } catch (std::exception& e) {
10563       {
10564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10565       };
10566     } catch (Dali::DaliException e) {
10567       {
10568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10569       };
10570     } catch (...) {
10571       {
10572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10573       };
10574     }
10575   }
10576
10577   jresult = result;
10578   return jresult;
10579 }
10580
10581
10582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10583   unsigned int jresult ;
10584   Dali::Degree arg1 ;
10585   Dali::Radian arg2 ;
10586   Dali::Degree *argp1 ;
10587   Dali::Radian *argp2 ;
10588   bool result;
10589
10590   argp1 = (Dali::Degree *)jarg1;
10591   if (!argp1) {
10592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10593     return 0;
10594   }
10595   arg1 = *argp1;
10596   argp2 = (Dali::Radian *)jarg2;
10597   if (!argp2) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10599     return 0;
10600   }
10601   arg2 = *argp2;
10602   {
10603     try {
10604       result = (bool)Dali::operator >(arg1,arg2);
10605     } catch (std::out_of_range& e) {
10606       {
10607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10608       };
10609     } catch (std::exception& e) {
10610       {
10611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10612       };
10613     } catch (Dali::DaliException e) {
10614       {
10615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10616       };
10617     } catch (...) {
10618       {
10619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10620       };
10621     }
10622   }
10623
10624   jresult = result;
10625   return jresult;
10626 }
10627
10628
10629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10630   unsigned int jresult ;
10631   Dali::Radian arg1 ;
10632   Dali::Radian arg2 ;
10633   Dali::Radian *argp1 ;
10634   Dali::Radian *argp2 ;
10635   bool result;
10636
10637   argp1 = (Dali::Radian *)jarg1;
10638   if (!argp1) {
10639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10640     return 0;
10641   }
10642   arg1 = *argp1;
10643   argp2 = (Dali::Radian *)jarg2;
10644   if (!argp2) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10646     return 0;
10647   }
10648   arg2 = *argp2;
10649   {
10650     try {
10651       result = (bool)Dali::operator <(arg1,arg2);
10652     } catch (std::out_of_range& e) {
10653       {
10654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10655       };
10656     } catch (std::exception& e) {
10657       {
10658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (Dali::DaliException e) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670
10671   jresult = result;
10672   return jresult;
10673 }
10674
10675
10676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10677   unsigned int jresult ;
10678   Dali::Radian arg1 ;
10679   Dali::Degree arg2 ;
10680   Dali::Radian *argp1 ;
10681   Dali::Degree *argp2 ;
10682   bool result;
10683
10684   argp1 = (Dali::Radian *)jarg1;
10685   if (!argp1) {
10686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10687     return 0;
10688   }
10689   arg1 = *argp1;
10690   argp2 = (Dali::Degree *)jarg2;
10691   if (!argp2) {
10692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10693     return 0;
10694   }
10695   arg2 = *argp2;
10696   {
10697     try {
10698       result = (bool)Dali::operator <(arg1,arg2);
10699     } catch (std::out_of_range& e) {
10700       {
10701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10702       };
10703     } catch (std::exception& e) {
10704       {
10705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10706       };
10707     } catch (Dali::DaliException e) {
10708       {
10709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10710       };
10711     } catch (...) {
10712       {
10713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10714       };
10715     }
10716   }
10717
10718   jresult = result;
10719   return jresult;
10720 }
10721
10722
10723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10724   unsigned int jresult ;
10725   Dali::Degree arg1 ;
10726   Dali::Radian arg2 ;
10727   Dali::Degree *argp1 ;
10728   Dali::Radian *argp2 ;
10729   bool result;
10730
10731   argp1 = (Dali::Degree *)jarg1;
10732   if (!argp1) {
10733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10734     return 0;
10735   }
10736   arg1 = *argp1;
10737   argp2 = (Dali::Radian *)jarg2;
10738   if (!argp2) {
10739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10740     return 0;
10741   }
10742   arg2 = *argp2;
10743   {
10744     try {
10745       result = (bool)Dali::operator <(arg1,arg2);
10746     } catch (std::out_of_range& e) {
10747       {
10748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10749       };
10750     } catch (std::exception& e) {
10751       {
10752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10753       };
10754     } catch (Dali::DaliException e) {
10755       {
10756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10757       };
10758     } catch (...) {
10759       {
10760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10761       };
10762     }
10763   }
10764
10765   jresult = result;
10766   return jresult;
10767 }
10768
10769
10770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10771   void * jresult ;
10772   Dali::Radian arg1 ;
10773   float arg2 ;
10774   Dali::Radian *argp1 ;
10775   Dali::Radian result;
10776
10777   argp1 = (Dali::Radian *)jarg1;
10778   if (!argp1) {
10779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10780     return 0;
10781   }
10782   arg1 = *argp1;
10783   arg2 = (float)jarg2;
10784   {
10785     try {
10786       result = Dali::operator *(arg1,arg2);
10787     } catch (std::out_of_range& e) {
10788       {
10789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10790       };
10791     } catch (std::exception& e) {
10792       {
10793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10794       };
10795     } catch (Dali::DaliException e) {
10796       {
10797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10798       };
10799     } catch (...) {
10800       {
10801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10802       };
10803     }
10804   }
10805
10806   jresult = new Dali::Radian((const Dali::Radian &)result);
10807   return jresult;
10808 }
10809
10810
10811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10812   void * jresult ;
10813   Dali::Radian arg1 ;
10814   Dali::Radian *argp1 ;
10815   Dali::Radian result;
10816
10817   argp1 = (Dali::Radian *)jarg1;
10818   if (!argp1) {
10819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10820     return 0;
10821   }
10822   arg1 = *argp1;
10823   {
10824     try {
10825       result = Dali::operator -(arg1);
10826     } catch (std::out_of_range& e) {
10827       {
10828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10829       };
10830     } catch (std::exception& e) {
10831       {
10832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10833       };
10834     } catch (Dali::DaliException e) {
10835       {
10836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10837       };
10838     } catch (...) {
10839       {
10840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10841       };
10842     }
10843   }
10844
10845   jresult = new Dali::Radian((const Dali::Radian &)result);
10846   return jresult;
10847 }
10848
10849
10850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10851   void * jresult ;
10852   Dali::Radian arg1 ;
10853   float arg2 ;
10854   float arg3 ;
10855   Dali::Radian *argp1 ;
10856   Dali::Radian result;
10857
10858   argp1 = (Dali::Radian *)jarg1;
10859   if (!argp1) {
10860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10861     return 0;
10862   }
10863   arg1 = *argp1;
10864   arg2 = (float)jarg2;
10865   arg3 = (float)jarg3;
10866   {
10867     try {
10868       result = Dali::Clamp(arg1,arg2,arg3);
10869     } catch (std::out_of_range& e) {
10870       {
10871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10872       };
10873     } catch (std::exception& e) {
10874       {
10875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10876       };
10877     } catch (Dali::DaliException e) {
10878       {
10879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10880       };
10881     } catch (...) {
10882       {
10883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10884       };
10885     }
10886   }
10887
10888   jresult = new Dali::Radian((const Dali::Radian &)result);
10889   return jresult;
10890 }
10891
10892
10893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10894   void * jresult ;
10895   Dali::Quaternion *result = 0 ;
10896
10897   {
10898     try {
10899       result = (Dali::Quaternion *)new Dali::Quaternion();
10900     } catch (std::out_of_range& e) {
10901       {
10902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10903       };
10904     } catch (std::exception& e) {
10905       {
10906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10907       };
10908     } catch (Dali::DaliException e) {
10909       {
10910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10911       };
10912     } catch (...) {
10913       {
10914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10915       };
10916     }
10917   }
10918
10919   jresult = (void *)result;
10920   return jresult;
10921 }
10922
10923
10924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10925   void * jresult ;
10926   Dali::Radian arg1 ;
10927   Dali::Vector3 *arg2 = 0 ;
10928   Dali::Radian *argp1 ;
10929   Dali::Quaternion *result = 0 ;
10930
10931   argp1 = (Dali::Radian *)jarg1;
10932   if (!argp1) {
10933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10934     return 0;
10935   }
10936   arg1 = *argp1;
10937   arg2 = (Dali::Vector3 *)jarg2;
10938   if (!arg2) {
10939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10940     return 0;
10941   }
10942   {
10943     try {
10944       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10945     } catch (std::out_of_range& e) {
10946       {
10947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10948       };
10949     } catch (std::exception& e) {
10950       {
10951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10952       };
10953     } catch (Dali::DaliException e) {
10954       {
10955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10956       };
10957     } catch (...) {
10958       {
10959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10960       };
10961     }
10962   }
10963
10964   jresult = (void *)result;
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10970   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10971
10972   arg1 = (Dali::Quaternion *)jarg1;
10973   {
10974     try {
10975       delete arg1;
10976     } catch (std::out_of_range& e) {
10977       {
10978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10979       };
10980     } catch (std::exception& e) {
10981       {
10982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10983       };
10984     } catch (Dali::DaliException e) {
10985       {
10986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10987       };
10988     } catch (...) {
10989       {
10990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10991       };
10992     }
10993   }
10994
10995 }
10996
10997
10998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10999   void * jresult ;
11000   Dali::Quaternion *result = 0 ;
11001
11002   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11003   jresult = (void *)result;
11004   return jresult;
11005 }
11006
11007
11008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11009   unsigned int jresult ;
11010   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11011   bool result;
11012
11013   arg1 = (Dali::Quaternion *)jarg1;
11014   {
11015     try {
11016       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11017     } catch (std::out_of_range& e) {
11018       {
11019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11020       };
11021     } catch (std::exception& e) {
11022       {
11023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11024       };
11025     } catch (Dali::DaliException e) {
11026       {
11027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11028       };
11029     } catch (...) {
11030       {
11031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11032       };
11033     }
11034   }
11035
11036   jresult = result;
11037   return jresult;
11038 }
11039
11040
11041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11042   unsigned int jresult ;
11043   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11044   Dali::Vector3 *arg2 = 0 ;
11045   Dali::Radian *arg3 = 0 ;
11046   bool result;
11047
11048   arg1 = (Dali::Quaternion *)jarg1;
11049   arg2 = (Dali::Vector3 *)jarg2;
11050   if (!arg2) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11052     return 0;
11053   }
11054   arg3 = (Dali::Radian *)jarg3;
11055   if (!arg3) {
11056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11057     return 0;
11058   }
11059   {
11060     try {
11061       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11062     } catch (std::out_of_range& e) {
11063       {
11064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11065       };
11066     } catch (std::exception& e) {
11067       {
11068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11069       };
11070     } catch (Dali::DaliException e) {
11071       {
11072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11073       };
11074     } catch (...) {
11075       {
11076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11077       };
11078     }
11079   }
11080
11081   jresult = result;
11082   return jresult;
11083 }
11084
11085
11086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11087   void * jresult ;
11088   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11089   Dali::Quaternion *arg2 = 0 ;
11090   Dali::Quaternion result;
11091
11092   arg1 = (Dali::Quaternion *)jarg1;
11093   arg2 = (Dali::Quaternion *)jarg2;
11094   if (!arg2) {
11095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11096     return 0;
11097   }
11098   {
11099     try {
11100       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11101     } catch (std::out_of_range& e) {
11102       {
11103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11104       };
11105     } catch (std::exception& e) {
11106       {
11107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11108       };
11109     } catch (Dali::DaliException e) {
11110       {
11111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11112       };
11113     } catch (...) {
11114       {
11115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11116       };
11117     }
11118   }
11119
11120   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11121   return jresult;
11122 }
11123
11124
11125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11126   void * jresult ;
11127   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11128   Dali::Quaternion *arg2 = 0 ;
11129   Dali::Quaternion result;
11130
11131   arg1 = (Dali::Quaternion *)jarg1;
11132   arg2 = (Dali::Quaternion *)jarg2;
11133   if (!arg2) {
11134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11135     return 0;
11136   }
11137   {
11138     try {
11139       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11140     } catch (std::out_of_range& e) {
11141       {
11142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11143       };
11144     } catch (std::exception& e) {
11145       {
11146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11147       };
11148     } catch (Dali::DaliException e) {
11149       {
11150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11151       };
11152     } catch (...) {
11153       {
11154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11155       };
11156     }
11157   }
11158
11159   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11160   return jresult;
11161 }
11162
11163
11164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11165   void * jresult ;
11166   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11167   Dali::Quaternion *arg2 = 0 ;
11168   Dali::Quaternion result;
11169
11170   arg1 = (Dali::Quaternion *)jarg1;
11171   arg2 = (Dali::Quaternion *)jarg2;
11172   if (!arg2) {
11173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11174     return 0;
11175   }
11176   {
11177     try {
11178       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11179     } catch (std::out_of_range& e) {
11180       {
11181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11182       };
11183     } catch (std::exception& e) {
11184       {
11185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11186       };
11187     } catch (Dali::DaliException e) {
11188       {
11189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11190       };
11191     } catch (...) {
11192       {
11193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11194       };
11195     }
11196   }
11197
11198   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11199   return jresult;
11200 }
11201
11202
11203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11204   void * jresult ;
11205   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11206   Dali::Vector3 *arg2 = 0 ;
11207   Dali::Vector3 result;
11208
11209   arg1 = (Dali::Quaternion *)jarg1;
11210   arg2 = (Dali::Vector3 *)jarg2;
11211   if (!arg2) {
11212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11213     return 0;
11214   }
11215   {
11216     try {
11217       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11218     } catch (std::out_of_range& e) {
11219       {
11220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11221       };
11222     } catch (std::exception& e) {
11223       {
11224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11225       };
11226     } catch (Dali::DaliException e) {
11227       {
11228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11229       };
11230     } catch (...) {
11231       {
11232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11233       };
11234     }
11235   }
11236
11237   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11238   return jresult;
11239 }
11240
11241
11242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11243   void * jresult ;
11244   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11245   Dali::Quaternion *arg2 = 0 ;
11246   Dali::Quaternion result;
11247
11248   arg1 = (Dali::Quaternion *)jarg1;
11249   arg2 = (Dali::Quaternion *)jarg2;
11250   if (!arg2) {
11251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11252     return 0;
11253   }
11254   {
11255     try {
11256       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11257     } catch (std::out_of_range& e) {
11258       {
11259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11260       };
11261     } catch (std::exception& e) {
11262       {
11263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11264       };
11265     } catch (Dali::DaliException e) {
11266       {
11267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11268       };
11269     } catch (...) {
11270       {
11271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11272       };
11273     }
11274   }
11275
11276   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11277   return jresult;
11278 }
11279
11280
11281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11282   void * jresult ;
11283   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11284   float arg2 ;
11285   Dali::Quaternion result;
11286
11287   arg1 = (Dali::Quaternion *)jarg1;
11288   arg2 = (float)jarg2;
11289   {
11290     try {
11291       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11292     } catch (std::out_of_range& e) {
11293       {
11294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11295       };
11296     } catch (std::exception& e) {
11297       {
11298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11299       };
11300     } catch (Dali::DaliException e) {
11301       {
11302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11303       };
11304     } catch (...) {
11305       {
11306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11307       };
11308     }
11309   }
11310
11311   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11312   return jresult;
11313 }
11314
11315
11316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11317   void * jresult ;
11318   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11319   float arg2 ;
11320   Dali::Quaternion result;
11321
11322   arg1 = (Dali::Quaternion *)jarg1;
11323   arg2 = (float)jarg2;
11324   {
11325     try {
11326       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11327     } catch (std::out_of_range& e) {
11328       {
11329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11330       };
11331     } catch (std::exception& e) {
11332       {
11333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11334       };
11335     } catch (Dali::DaliException e) {
11336       {
11337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11338       };
11339     } catch (...) {
11340       {
11341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11342       };
11343     }
11344   }
11345
11346   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11347   return jresult;
11348 }
11349
11350
11351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11352   void * jresult ;
11353   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11354   Dali::Quaternion result;
11355
11356   arg1 = (Dali::Quaternion *)jarg1;
11357   {
11358     try {
11359       result = ((Dali::Quaternion const *)arg1)->operator -();
11360     } catch (std::out_of_range& e) {
11361       {
11362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11363       };
11364     } catch (std::exception& e) {
11365       {
11366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11367       };
11368     } catch (Dali::DaliException e) {
11369       {
11370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11371       };
11372     } catch (...) {
11373       {
11374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11375       };
11376     }
11377   }
11378
11379   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11380   return jresult;
11381 }
11382
11383
11384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11385   void * jresult ;
11386   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11387   Dali::Quaternion *arg2 = 0 ;
11388   Dali::Quaternion *result = 0 ;
11389
11390   arg1 = (Dali::Quaternion *)jarg1;
11391   arg2 = (Dali::Quaternion *)jarg2;
11392   if (!arg2) {
11393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11394     return 0;
11395   }
11396   {
11397     try {
11398       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11399     } catch (std::out_of_range& e) {
11400       {
11401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11402       };
11403     } catch (std::exception& e) {
11404       {
11405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11406       };
11407     } catch (Dali::DaliException e) {
11408       {
11409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11410       };
11411     } catch (...) {
11412       {
11413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11414       };
11415     }
11416   }
11417
11418   jresult = (void *)result;
11419   return jresult;
11420 }
11421
11422
11423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11424   void * jresult ;
11425   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11426   Dali::Quaternion *arg2 = 0 ;
11427   Dali::Quaternion *result = 0 ;
11428
11429   arg1 = (Dali::Quaternion *)jarg1;
11430   arg2 = (Dali::Quaternion *)jarg2;
11431   if (!arg2) {
11432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11433     return 0;
11434   }
11435   {
11436     try {
11437       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11438     } catch (std::out_of_range& e) {
11439       {
11440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11441       };
11442     } catch (std::exception& e) {
11443       {
11444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11445       };
11446     } catch (Dali::DaliException e) {
11447       {
11448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11449       };
11450     } catch (...) {
11451       {
11452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11453       };
11454     }
11455   }
11456
11457   jresult = (void *)result;
11458   return jresult;
11459 }
11460
11461
11462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11463   void * jresult ;
11464   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11465   Dali::Quaternion *arg2 = 0 ;
11466   Dali::Quaternion *result = 0 ;
11467
11468   arg1 = (Dali::Quaternion *)jarg1;
11469   arg2 = (Dali::Quaternion *)jarg2;
11470   if (!arg2) {
11471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11472     return 0;
11473   }
11474   {
11475     try {
11476       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11477     } catch (std::out_of_range& e) {
11478       {
11479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11480       };
11481     } catch (std::exception& e) {
11482       {
11483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11484       };
11485     } catch (Dali::DaliException e) {
11486       {
11487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11488       };
11489     } catch (...) {
11490       {
11491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11492       };
11493     }
11494   }
11495
11496   jresult = (void *)result;
11497   return jresult;
11498 }
11499
11500
11501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11502   void * jresult ;
11503   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11504   float arg2 ;
11505   Dali::Quaternion *result = 0 ;
11506
11507   arg1 = (Dali::Quaternion *)jarg1;
11508   arg2 = (float)jarg2;
11509   {
11510     try {
11511       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11512     } catch (std::out_of_range& e) {
11513       {
11514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11515       };
11516     } catch (std::exception& e) {
11517       {
11518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11519       };
11520     } catch (Dali::DaliException e) {
11521       {
11522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11523       };
11524     } catch (...) {
11525       {
11526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11527       };
11528     }
11529   }
11530
11531   jresult = (void *)result;
11532   return jresult;
11533 }
11534
11535
11536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11537   void * jresult ;
11538   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11539   float arg2 ;
11540   Dali::Quaternion *result = 0 ;
11541
11542   arg1 = (Dali::Quaternion *)jarg1;
11543   arg2 = (float)jarg2;
11544   {
11545     try {
11546       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11547     } catch (std::out_of_range& e) {
11548       {
11549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11550       };
11551     } catch (std::exception& e) {
11552       {
11553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11554       };
11555     } catch (Dali::DaliException e) {
11556       {
11557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11558       };
11559     } catch (...) {
11560       {
11561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11562       };
11563     }
11564   }
11565
11566   jresult = (void *)result;
11567   return jresult;
11568 }
11569
11570
11571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11572   unsigned int jresult ;
11573   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11574   Dali::Quaternion *arg2 = 0 ;
11575   bool result;
11576
11577   arg1 = (Dali::Quaternion *)jarg1;
11578   arg2 = (Dali::Quaternion *)jarg2;
11579   if (!arg2) {
11580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11581     return 0;
11582   }
11583   {
11584     try {
11585       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11586     } catch (std::out_of_range& e) {
11587       {
11588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11589       };
11590     } catch (std::exception& e) {
11591       {
11592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11593       };
11594     } catch (Dali::DaliException e) {
11595       {
11596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11597       };
11598     } catch (...) {
11599       {
11600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11601       };
11602     }
11603   }
11604
11605   jresult = result;
11606   return jresult;
11607 }
11608
11609
11610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11611   unsigned int jresult ;
11612   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11613   Dali::Quaternion *arg2 = 0 ;
11614   bool result;
11615
11616   arg1 = (Dali::Quaternion *)jarg1;
11617   arg2 = (Dali::Quaternion *)jarg2;
11618   if (!arg2) {
11619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11620     return 0;
11621   }
11622   {
11623     try {
11624       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11625     } catch (std::out_of_range& e) {
11626       {
11627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11628       };
11629     } catch (std::exception& e) {
11630       {
11631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11632       };
11633     } catch (Dali::DaliException e) {
11634       {
11635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11636       };
11637     } catch (...) {
11638       {
11639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11640       };
11641     }
11642   }
11643
11644   jresult = result;
11645   return jresult;
11646 }
11647
11648
11649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11650   float jresult ;
11651   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11652   float result;
11653
11654   arg1 = (Dali::Quaternion *)jarg1;
11655   {
11656     try {
11657       result = (float)((Dali::Quaternion const *)arg1)->Length();
11658     } catch (std::out_of_range& e) {
11659       {
11660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11661       };
11662     } catch (std::exception& e) {
11663       {
11664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11665       };
11666     } catch (Dali::DaliException e) {
11667       {
11668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11669       };
11670     } catch (...) {
11671       {
11672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11673       };
11674     }
11675   }
11676
11677   jresult = result;
11678   return jresult;
11679 }
11680
11681
11682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11683   float jresult ;
11684   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11685   float result;
11686
11687   arg1 = (Dali::Quaternion *)jarg1;
11688   {
11689     try {
11690       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11691     } catch (std::out_of_range& e) {
11692       {
11693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11694       };
11695     } catch (std::exception& e) {
11696       {
11697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11698       };
11699     } catch (Dali::DaliException e) {
11700       {
11701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11702       };
11703     } catch (...) {
11704       {
11705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11706       };
11707     }
11708   }
11709
11710   jresult = result;
11711   return jresult;
11712 }
11713
11714
11715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11716   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11717
11718   arg1 = (Dali::Quaternion *)jarg1;
11719   {
11720     try {
11721       (arg1)->Normalize();
11722     } catch (std::out_of_range& e) {
11723       {
11724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11725       };
11726     } catch (std::exception& e) {
11727       {
11728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11729       };
11730     } catch (Dali::DaliException e) {
11731       {
11732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11733       };
11734     } catch (...) {
11735       {
11736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11737       };
11738     }
11739   }
11740
11741 }
11742
11743
11744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11745   void * jresult ;
11746   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11747   Dali::Quaternion result;
11748
11749   arg1 = (Dali::Quaternion *)jarg1;
11750   {
11751     try {
11752       result = ((Dali::Quaternion const *)arg1)->Normalized();
11753     } catch (std::out_of_range& e) {
11754       {
11755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11756       };
11757     } catch (std::exception& e) {
11758       {
11759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11760       };
11761     } catch (Dali::DaliException e) {
11762       {
11763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11764       };
11765     } catch (...) {
11766       {
11767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11768       };
11769     }
11770   }
11771
11772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11773   return jresult;
11774 }
11775
11776
11777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11778   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11779
11780   arg1 = (Dali::Quaternion *)jarg1;
11781   {
11782     try {
11783       (arg1)->Conjugate();
11784     } catch (std::out_of_range& e) {
11785       {
11786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11787       };
11788     } catch (std::exception& e) {
11789       {
11790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11791       };
11792     } catch (Dali::DaliException e) {
11793       {
11794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11795       };
11796     } catch (...) {
11797       {
11798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11799       };
11800     }
11801   }
11802
11803 }
11804
11805
11806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11807   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11808
11809   arg1 = (Dali::Quaternion *)jarg1;
11810   {
11811     try {
11812       (arg1)->Invert();
11813     } catch (std::out_of_range& e) {
11814       {
11815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11816       };
11817     } catch (std::exception& e) {
11818       {
11819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11820       };
11821     } catch (Dali::DaliException e) {
11822       {
11823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11824       };
11825     } catch (...) {
11826       {
11827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11828       };
11829     }
11830   }
11831
11832 }
11833
11834
11835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11836   void * jresult ;
11837   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11838   Dali::Quaternion result;
11839
11840   arg1 = (Dali::Quaternion *)jarg1;
11841   {
11842     try {
11843       result = ((Dali::Quaternion const *)arg1)->Log();
11844     } catch (std::out_of_range& e) {
11845       {
11846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11847       };
11848     } catch (std::exception& e) {
11849       {
11850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11851       };
11852     } catch (Dali::DaliException e) {
11853       {
11854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11855       };
11856     } catch (...) {
11857       {
11858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11859       };
11860     }
11861   }
11862
11863   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11864   return jresult;
11865 }
11866
11867
11868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11869   void * jresult ;
11870   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11871   Dali::Quaternion result;
11872
11873   arg1 = (Dali::Quaternion *)jarg1;
11874   {
11875     try {
11876       result = ((Dali::Quaternion const *)arg1)->Exp();
11877     } catch (std::out_of_range& e) {
11878       {
11879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11880       };
11881     } catch (std::exception& e) {
11882       {
11883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11884       };
11885     } catch (Dali::DaliException e) {
11886       {
11887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11888       };
11889     } catch (...) {
11890       {
11891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11892       };
11893     }
11894   }
11895
11896   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11897   return jresult;
11898 }
11899
11900
11901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11902   float jresult ;
11903   Dali::Quaternion *arg1 = 0 ;
11904   Dali::Quaternion *arg2 = 0 ;
11905   float result;
11906
11907   arg1 = (Dali::Quaternion *)jarg1;
11908   if (!arg1) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   arg2 = (Dali::Quaternion *)jarg2;
11913   if (!arg2) {
11914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11915     return 0;
11916   }
11917   {
11918     try {
11919       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11920     } catch (std::out_of_range& e) {
11921       {
11922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11923       };
11924     } catch (std::exception& e) {
11925       {
11926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11927       };
11928     } catch (Dali::DaliException e) {
11929       {
11930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11931       };
11932     } catch (...) {
11933       {
11934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11935       };
11936     }
11937   }
11938
11939   jresult = result;
11940   return jresult;
11941 }
11942
11943
11944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11945   void * jresult ;
11946   Dali::Quaternion *arg1 = 0 ;
11947   Dali::Quaternion *arg2 = 0 ;
11948   float arg3 ;
11949   Dali::Quaternion result;
11950
11951   arg1 = (Dali::Quaternion *)jarg1;
11952   if (!arg1) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg2 = (Dali::Quaternion *)jarg2;
11957   if (!arg2) {
11958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11959     return 0;
11960   }
11961   arg3 = (float)jarg3;
11962   {
11963     try {
11964       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11965     } catch (std::out_of_range& e) {
11966       {
11967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11968       };
11969     } catch (std::exception& e) {
11970       {
11971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11972       };
11973     } catch (Dali::DaliException e) {
11974       {
11975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11976       };
11977     } catch (...) {
11978       {
11979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11980       };
11981     }
11982   }
11983
11984   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11985   return jresult;
11986 }
11987
11988
11989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11990   void * jresult ;
11991   Dali::Quaternion *arg1 = 0 ;
11992   Dali::Quaternion *arg2 = 0 ;
11993   float arg3 ;
11994   Dali::Quaternion result;
11995
11996   arg1 = (Dali::Quaternion *)jarg1;
11997   if (!arg1) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11999     return 0;
12000   }
12001   arg2 = (Dali::Quaternion *)jarg2;
12002   if (!arg2) {
12003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12004     return 0;
12005   }
12006   arg3 = (float)jarg3;
12007   {
12008     try {
12009       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12010     } catch (std::out_of_range& e) {
12011       {
12012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12013       };
12014     } catch (std::exception& e) {
12015       {
12016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12017       };
12018     } catch (Dali::DaliException e) {
12019       {
12020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12021       };
12022     } catch (...) {
12023       {
12024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12025       };
12026     }
12027   }
12028
12029   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12030   return jresult;
12031 }
12032
12033
12034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12035   void * jresult ;
12036   Dali::Quaternion *arg1 = 0 ;
12037   Dali::Quaternion *arg2 = 0 ;
12038   float arg3 ;
12039   Dali::Quaternion result;
12040
12041   arg1 = (Dali::Quaternion *)jarg1;
12042   if (!arg1) {
12043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12044     return 0;
12045   }
12046   arg2 = (Dali::Quaternion *)jarg2;
12047   if (!arg2) {
12048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12049     return 0;
12050   }
12051   arg3 = (float)jarg3;
12052   {
12053     try {
12054       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12055     } catch (std::out_of_range& e) {
12056       {
12057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12058       };
12059     } catch (std::exception& e) {
12060       {
12061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12062       };
12063     } catch (Dali::DaliException e) {
12064       {
12065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12066       };
12067     } catch (...) {
12068       {
12069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12070       };
12071     }
12072   }
12073
12074   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12075   return jresult;
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12080   void * jresult ;
12081   Dali::Quaternion *arg1 = 0 ;
12082   Dali::Quaternion *arg2 = 0 ;
12083   Dali::Quaternion *arg3 = 0 ;
12084   Dali::Quaternion *arg4 = 0 ;
12085   float arg5 ;
12086   Dali::Quaternion result;
12087
12088   arg1 = (Dali::Quaternion *)jarg1;
12089   if (!arg1) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg2 = (Dali::Quaternion *)jarg2;
12094   if (!arg2) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg3 = (Dali::Quaternion *)jarg3;
12099   if (!arg3) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg4 = (Dali::Quaternion *)jarg4;
12104   if (!arg4) {
12105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12106     return 0;
12107   }
12108   arg5 = (float)jarg5;
12109   {
12110     try {
12111       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12112     } catch (std::out_of_range& e) {
12113       {
12114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12115       };
12116     } catch (std::exception& e) {
12117       {
12118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12119       };
12120     } catch (Dali::DaliException e) {
12121       {
12122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12123       };
12124     } catch (...) {
12125       {
12126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12127       };
12128     }
12129   }
12130
12131   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12132   return jresult;
12133 }
12134
12135
12136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12137   float jresult ;
12138   Dali::Quaternion *arg1 = 0 ;
12139   Dali::Quaternion *arg2 = 0 ;
12140   float result;
12141
12142   arg1 = (Dali::Quaternion *)jarg1;
12143   if (!arg1) {
12144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12145     return 0;
12146   }
12147   arg2 = (Dali::Quaternion *)jarg2;
12148   if (!arg2) {
12149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12150     return 0;
12151   }
12152   {
12153     try {
12154       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12155     } catch (std::out_of_range& e) {
12156       {
12157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12158       };
12159     } catch (std::exception& e) {
12160       {
12161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12162       };
12163     } catch (Dali::DaliException e) {
12164       {
12165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12170       };
12171     }
12172   }
12173
12174   jresult = result;
12175   return jresult;
12176 }
12177
12178
12179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12180   void * jresult ;
12181   Dali::Matrix *result = 0 ;
12182
12183   {
12184     try {
12185       result = (Dali::Matrix *)new Dali::Matrix();
12186     } catch (std::out_of_range& e) {
12187       {
12188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12189       };
12190     } catch (std::exception& e) {
12191       {
12192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12193       };
12194     } catch (Dali::DaliException e) {
12195       {
12196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12197       };
12198     } catch (...) {
12199       {
12200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12201       };
12202     }
12203   }
12204
12205   jresult = (void *)result;
12206   return jresult;
12207 }
12208
12209
12210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12211   void * jresult ;
12212   bool arg1 ;
12213   Dali::Matrix *result = 0 ;
12214
12215   arg1 = jarg1 ? true : false;
12216   {
12217     try {
12218       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12219     } catch (std::out_of_range& e) {
12220       {
12221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12222       };
12223     } catch (std::exception& e) {
12224       {
12225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12226       };
12227     } catch (Dali::DaliException e) {
12228       {
12229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12230       };
12231     } catch (...) {
12232       {
12233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12234       };
12235     }
12236   }
12237
12238   jresult = (void *)result;
12239   return jresult;
12240 }
12241
12242
12243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12244   void * jresult ;
12245   float *arg1 = (float *) 0 ;
12246   Dali::Matrix *result = 0 ;
12247
12248   arg1 = jarg1;
12249   {
12250     try {
12251       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12252     } catch (std::out_of_range& e) {
12253       {
12254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12255       };
12256     } catch (std::exception& e) {
12257       {
12258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12259       };
12260     } catch (Dali::DaliException e) {
12261       {
12262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12263       };
12264     } catch (...) {
12265       {
12266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12267       };
12268     }
12269   }
12270
12271   jresult = (void *)result;
12272
12273
12274   return jresult;
12275 }
12276
12277
12278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12279   void * jresult ;
12280   Dali::Quaternion *arg1 = 0 ;
12281   Dali::Matrix *result = 0 ;
12282
12283   arg1 = (Dali::Quaternion *)jarg1;
12284   if (!arg1) {
12285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12286     return 0;
12287   }
12288   {
12289     try {
12290       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12291     } catch (std::out_of_range& e) {
12292       {
12293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12294       };
12295     } catch (std::exception& e) {
12296       {
12297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12298       };
12299     } catch (Dali::DaliException e) {
12300       {
12301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12302       };
12303     } catch (...) {
12304       {
12305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12306       };
12307     }
12308   }
12309
12310   jresult = (void *)result;
12311   return jresult;
12312 }
12313
12314
12315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12316   void * jresult ;
12317   Dali::Matrix *arg1 = 0 ;
12318   Dali::Matrix *result = 0 ;
12319
12320   arg1 = (Dali::Matrix *)jarg1;
12321   if (!arg1) {
12322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12323     return 0;
12324   }
12325   {
12326     try {
12327       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12328     } catch (std::out_of_range& e) {
12329       {
12330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (std::exception& e) {
12333       {
12334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12335       };
12336     } catch (Dali::DaliException e) {
12337       {
12338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12339       };
12340     } catch (...) {
12341       {
12342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12343       };
12344     }
12345   }
12346
12347   jresult = (void *)result;
12348   return jresult;
12349 }
12350
12351
12352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12353   void * jresult ;
12354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12355   Dali::Matrix *arg2 = 0 ;
12356   Dali::Matrix *result = 0 ;
12357
12358   arg1 = (Dali::Matrix *)jarg1;
12359   arg2 = (Dali::Matrix *)jarg2;
12360   if (!arg2) {
12361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12362     return 0;
12363   }
12364   {
12365     try {
12366       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12367     } catch (std::out_of_range& e) {
12368       {
12369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12370       };
12371     } catch (std::exception& e) {
12372       {
12373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12374       };
12375     } catch (Dali::DaliException e) {
12376       {
12377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12378       };
12379     } catch (...) {
12380       {
12381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12382       };
12383     }
12384   }
12385
12386   jresult = (void *)result;
12387   return jresult;
12388 }
12389
12390
12391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12392   void * jresult ;
12393   Dali::Matrix *result = 0 ;
12394
12395   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12396   jresult = (void *)result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12402   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12403
12404   arg1 = (Dali::Matrix *)jarg1;
12405   {
12406     try {
12407       (arg1)->SetIdentity();
12408     } catch (std::out_of_range& e) {
12409       {
12410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12411       };
12412     } catch (std::exception& e) {
12413       {
12414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12415       };
12416     } catch (Dali::DaliException e) {
12417       {
12418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12419       };
12420     } catch (...) {
12421       {
12422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12423       };
12424     }
12425   }
12426
12427 }
12428
12429
12430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12431   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12432   Dali::Vector3 *arg2 = 0 ;
12433
12434   arg1 = (Dali::Matrix *)jarg1;
12435   arg2 = (Dali::Vector3 *)jarg2;
12436   if (!arg2) {
12437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12438     return ;
12439   }
12440   {
12441     try {
12442       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12443     } catch (std::out_of_range& e) {
12444       {
12445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12446       };
12447     } catch (std::exception& e) {
12448       {
12449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12450       };
12451     } catch (Dali::DaliException e) {
12452       {
12453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12454       };
12455     } catch (...) {
12456       {
12457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12458       };
12459     }
12460   }
12461
12462 }
12463
12464
12465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12466   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12467   Dali::Matrix *arg2 = 0 ;
12468
12469   arg1 = (Dali::Matrix *)jarg1;
12470   arg2 = (Dali::Matrix *)jarg2;
12471   if (!arg2) {
12472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12473     return ;
12474   }
12475   {
12476     try {
12477       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12478     } catch (std::out_of_range& e) {
12479       {
12480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12481       };
12482     } catch (std::exception& e) {
12483       {
12484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12485       };
12486     } catch (Dali::DaliException e) {
12487       {
12488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12489       };
12490     } catch (...) {
12491       {
12492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12493       };
12494     }
12495   }
12496
12497 }
12498
12499
12500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12501   unsigned int jresult ;
12502   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12503   bool result;
12504
12505   arg1 = (Dali::Matrix *)jarg1;
12506   {
12507     try {
12508       result = (bool)(arg1)->Invert();
12509     } catch (std::out_of_range& e) {
12510       {
12511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12512       };
12513     } catch (std::exception& e) {
12514       {
12515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12516       };
12517     } catch (Dali::DaliException e) {
12518       {
12519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12520       };
12521     } catch (...) {
12522       {
12523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12524       };
12525     }
12526   }
12527
12528   jresult = result;
12529   return jresult;
12530 }
12531
12532
12533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12534   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12535
12536   arg1 = (Dali::Matrix *)jarg1;
12537   {
12538     try {
12539       (arg1)->Transpose();
12540     } catch (std::out_of_range& e) {
12541       {
12542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12543       };
12544     } catch (std::exception& e) {
12545       {
12546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12547       };
12548     } catch (Dali::DaliException e) {
12549       {
12550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12551       };
12552     } catch (...) {
12553       {
12554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12555       };
12556     }
12557   }
12558
12559 }
12560
12561
12562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12563   void * jresult ;
12564   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12565   Dali::Vector3 result;
12566
12567   arg1 = (Dali::Matrix *)jarg1;
12568   {
12569     try {
12570       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12571     } catch (std::out_of_range& e) {
12572       {
12573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12574       };
12575     } catch (std::exception& e) {
12576       {
12577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12578       };
12579     } catch (Dali::DaliException e) {
12580       {
12581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12582       };
12583     } catch (...) {
12584       {
12585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12586       };
12587     }
12588   }
12589
12590   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12591   return jresult;
12592 }
12593
12594
12595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12596   void * jresult ;
12597   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12598   Dali::Vector3 result;
12599
12600   arg1 = (Dali::Matrix *)jarg1;
12601   {
12602     try {
12603       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12604     } catch (std::out_of_range& e) {
12605       {
12606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12607       };
12608     } catch (std::exception& e) {
12609       {
12610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12611       };
12612     } catch (Dali::DaliException e) {
12613       {
12614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12615       };
12616     } catch (...) {
12617       {
12618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12619       };
12620     }
12621   }
12622
12623   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12624   return jresult;
12625 }
12626
12627
12628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12629   void * jresult ;
12630   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12631   Dali::Vector3 result;
12632
12633   arg1 = (Dali::Matrix *)jarg1;
12634   {
12635     try {
12636       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12637     } catch (std::out_of_range& e) {
12638       {
12639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12640       };
12641     } catch (std::exception& e) {
12642       {
12643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12644       };
12645     } catch (Dali::DaliException e) {
12646       {
12647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12648       };
12649     } catch (...) {
12650       {
12651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12652       };
12653     }
12654   }
12655
12656   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12657   return jresult;
12658 }
12659
12660
12661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12662   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12663   Dali::Vector3 *arg2 = 0 ;
12664
12665   arg1 = (Dali::Matrix *)jarg1;
12666   arg2 = (Dali::Vector3 *)jarg2;
12667   if (!arg2) {
12668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12669     return ;
12670   }
12671   {
12672     try {
12673       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12674     } catch (std::out_of_range& e) {
12675       {
12676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12677       };
12678     } catch (std::exception& e) {
12679       {
12680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12681       };
12682     } catch (Dali::DaliException e) {
12683       {
12684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12685       };
12686     } catch (...) {
12687       {
12688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12689       };
12690     }
12691   }
12692
12693 }
12694
12695
12696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12697   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12698   Dali::Vector3 *arg2 = 0 ;
12699
12700   arg1 = (Dali::Matrix *)jarg1;
12701   arg2 = (Dali::Vector3 *)jarg2;
12702   if (!arg2) {
12703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12704     return ;
12705   }
12706   {
12707     try {
12708       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12709     } catch (std::out_of_range& e) {
12710       {
12711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12712       };
12713     } catch (std::exception& e) {
12714       {
12715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12716       };
12717     } catch (Dali::DaliException e) {
12718       {
12719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12720       };
12721     } catch (...) {
12722       {
12723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12724       };
12725     }
12726   }
12727
12728 }
12729
12730
12731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12732   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12733   Dali::Vector3 *arg2 = 0 ;
12734
12735   arg1 = (Dali::Matrix *)jarg1;
12736   arg2 = (Dali::Vector3 *)jarg2;
12737   if (!arg2) {
12738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12739     return ;
12740   }
12741   {
12742     try {
12743       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12744     } catch (std::out_of_range& e) {
12745       {
12746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12747       };
12748     } catch (std::exception& e) {
12749       {
12750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12751       };
12752     } catch (Dali::DaliException e) {
12753       {
12754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12755       };
12756     } catch (...) {
12757       {
12758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12759       };
12760     }
12761   }
12762
12763 }
12764
12765
12766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12767   void * jresult ;
12768   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12769   Dali::Vector4 *result = 0 ;
12770
12771   arg1 = (Dali::Matrix *)jarg1;
12772   {
12773     try {
12774       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12775     } catch (std::out_of_range& e) {
12776       {
12777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12778       };
12779     } catch (std::exception& e) {
12780       {
12781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12782       };
12783     } catch (Dali::DaliException e) {
12784       {
12785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12786       };
12787     } catch (...) {
12788       {
12789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12790       };
12791     }
12792   }
12793
12794   jresult = (void *)result;
12795   return jresult;
12796 }
12797
12798
12799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12800   void * jresult ;
12801   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12802   Dali::Vector3 *result = 0 ;
12803
12804   arg1 = (Dali::Matrix *)jarg1;
12805   {
12806     try {
12807       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12808     } catch (std::out_of_range& e) {
12809       {
12810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (std::exception& e) {
12813       {
12814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12815       };
12816     } catch (Dali::DaliException e) {
12817       {
12818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12819       };
12820     } catch (...) {
12821       {
12822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12823       };
12824     }
12825   }
12826
12827   jresult = (void *)result;
12828   return jresult;
12829 }
12830
12831
12832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12833   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12834   Dali::Vector4 *arg2 = 0 ;
12835
12836   arg1 = (Dali::Matrix *)jarg1;
12837   arg2 = (Dali::Vector4 *)jarg2;
12838   if (!arg2) {
12839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12840     return ;
12841   }
12842   {
12843     try {
12844       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12845     } catch (std::out_of_range& e) {
12846       {
12847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12848       };
12849     } catch (std::exception& e) {
12850       {
12851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12852       };
12853     } catch (Dali::DaliException e) {
12854       {
12855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12856       };
12857     } catch (...) {
12858       {
12859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12860       };
12861     }
12862   }
12863
12864 }
12865
12866
12867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12868   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12869   Dali::Vector3 *arg2 = 0 ;
12870
12871   arg1 = (Dali::Matrix *)jarg1;
12872   arg2 = (Dali::Vector3 *)jarg2;
12873   if (!arg2) {
12874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12875     return ;
12876   }
12877   {
12878     try {
12879       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12880     } catch (std::out_of_range& e) {
12881       {
12882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12883       };
12884     } catch (std::exception& e) {
12885       {
12886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12887       };
12888     } catch (Dali::DaliException e) {
12889       {
12890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12891       };
12892     } catch (...) {
12893       {
12894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12895       };
12896     }
12897   }
12898
12899 }
12900
12901
12902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12903   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12904
12905   arg1 = (Dali::Matrix *)jarg1;
12906   {
12907     try {
12908       (arg1)->OrthoNormalize();
12909     } catch (std::out_of_range& e) {
12910       {
12911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12912       };
12913     } catch (std::exception& e) {
12914       {
12915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12916       };
12917     } catch (Dali::DaliException e) {
12918       {
12919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12920       };
12921     } catch (...) {
12922       {
12923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12924       };
12925     }
12926   }
12927
12928 }
12929
12930
12931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12932   void * jresult ;
12933   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12934   float *result = 0 ;
12935
12936   arg1 = (Dali::Matrix *)jarg1;
12937   {
12938     try {
12939       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12940     } catch (std::out_of_range& e) {
12941       {
12942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12943       };
12944     } catch (std::exception& e) {
12945       {
12946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12947       };
12948     } catch (Dali::DaliException e) {
12949       {
12950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12951       };
12952     } catch (...) {
12953       {
12954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12955       };
12956     }
12957   }
12958
12959   jresult = (void *)result;
12960   return jresult;
12961 }
12962
12963
12964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12965   Dali::Matrix *arg1 = 0 ;
12966   Dali::Matrix *arg2 = 0 ;
12967   Dali::Matrix *arg3 = 0 ;
12968
12969   arg1 = (Dali::Matrix *)jarg1;
12970   if (!arg1) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12972     return ;
12973   }
12974   arg2 = (Dali::Matrix *)jarg2;
12975   if (!arg2) {
12976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12977     return ;
12978   }
12979   arg3 = (Dali::Matrix *)jarg3;
12980   if (!arg3) {
12981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12982     return ;
12983   }
12984   {
12985     try {
12986       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12987     } catch (std::out_of_range& e) {
12988       {
12989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12990       };
12991     } catch (std::exception& e) {
12992       {
12993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12994       };
12995     } catch (Dali::DaliException e) {
12996       {
12997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12998       };
12999     } catch (...) {
13000       {
13001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13002       };
13003     }
13004   }
13005
13006 }
13007
13008
13009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13010   Dali::Matrix *arg1 = 0 ;
13011   Dali::Matrix *arg2 = 0 ;
13012   Dali::Quaternion *arg3 = 0 ;
13013
13014   arg1 = (Dali::Matrix *)jarg1;
13015   if (!arg1) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13017     return ;
13018   }
13019   arg2 = (Dali::Matrix *)jarg2;
13020   if (!arg2) {
13021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13022     return ;
13023   }
13024   arg3 = (Dali::Quaternion *)jarg3;
13025   if (!arg3) {
13026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13027     return ;
13028   }
13029   {
13030     try {
13031       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13032     } catch (std::out_of_range& e) {
13033       {
13034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13035       };
13036     } catch (std::exception& e) {
13037       {
13038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13039       };
13040     } catch (Dali::DaliException e) {
13041       {
13042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13043       };
13044     } catch (...) {
13045       {
13046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13047       };
13048     }
13049   }
13050
13051 }
13052
13053
13054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13055   void * jresult ;
13056   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13057   Dali::Vector4 *arg2 = 0 ;
13058   Dali::Vector4 result;
13059
13060   arg1 = (Dali::Matrix *)jarg1;
13061   arg2 = (Dali::Vector4 *)jarg2;
13062   if (!arg2) {
13063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13064     return 0;
13065   }
13066   {
13067     try {
13068       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13069     } catch (std::out_of_range& e) {
13070       {
13071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13072       };
13073     } catch (std::exception& e) {
13074       {
13075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13076       };
13077     } catch (Dali::DaliException e) {
13078       {
13079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13080       };
13081     } catch (...) {
13082       {
13083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13084       };
13085     }
13086   }
13087
13088   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13089   return jresult;
13090 }
13091
13092
13093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13094   unsigned int jresult ;
13095   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13096   Dali::Matrix *arg2 = 0 ;
13097   bool result;
13098
13099   arg1 = (Dali::Matrix *)jarg1;
13100   arg2 = (Dali::Matrix *)jarg2;
13101   if (!arg2) {
13102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13103     return 0;
13104   }
13105   {
13106     try {
13107       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13108     } catch (std::out_of_range& e) {
13109       {
13110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13111       };
13112     } catch (std::exception& e) {
13113       {
13114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13115       };
13116     } catch (Dali::DaliException e) {
13117       {
13118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13119       };
13120     } catch (...) {
13121       {
13122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13123       };
13124     }
13125   }
13126
13127   jresult = result;
13128   return jresult;
13129 }
13130
13131
13132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13133   unsigned int jresult ;
13134   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13135   Dali::Matrix *arg2 = 0 ;
13136   bool result;
13137
13138   arg1 = (Dali::Matrix *)jarg1;
13139   arg2 = (Dali::Matrix *)jarg2;
13140   if (!arg2) {
13141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13142     return 0;
13143   }
13144   {
13145     try {
13146       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13147     } catch (std::out_of_range& e) {
13148       {
13149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13150       };
13151     } catch (std::exception& e) {
13152       {
13153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13154       };
13155     } catch (Dali::DaliException e) {
13156       {
13157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13158       };
13159     } catch (...) {
13160       {
13161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13162       };
13163     }
13164   }
13165
13166   jresult = result;
13167   return jresult;
13168 }
13169
13170
13171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13172   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13173   Dali::Vector3 *arg2 = 0 ;
13174   Dali::Quaternion *arg3 = 0 ;
13175   Dali::Vector3 *arg4 = 0 ;
13176
13177   arg1 = (Dali::Matrix *)jarg1;
13178   arg2 = (Dali::Vector3 *)jarg2;
13179   if (!arg2) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13181     return ;
13182   }
13183   arg3 = (Dali::Quaternion *)jarg3;
13184   if (!arg3) {
13185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13186     return ;
13187   }
13188   arg4 = (Dali::Vector3 *)jarg4;
13189   if (!arg4) {
13190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13191     return ;
13192   }
13193   {
13194     try {
13195       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13196     } catch (std::out_of_range& e) {
13197       {
13198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13199       };
13200     } catch (std::exception& e) {
13201       {
13202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13203       };
13204     } catch (Dali::DaliException e) {
13205       {
13206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13207       };
13208     } catch (...) {
13209       {
13210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13211       };
13212     }
13213   }
13214
13215 }
13216
13217
13218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13219   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13220   Dali::Vector3 *arg2 = 0 ;
13221   Dali::Quaternion *arg3 = 0 ;
13222   Dali::Vector3 *arg4 = 0 ;
13223
13224   arg1 = (Dali::Matrix *)jarg1;
13225   arg2 = (Dali::Vector3 *)jarg2;
13226   if (!arg2) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13228     return ;
13229   }
13230   arg3 = (Dali::Quaternion *)jarg3;
13231   if (!arg3) {
13232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13233     return ;
13234   }
13235   arg4 = (Dali::Vector3 *)jarg4;
13236   if (!arg4) {
13237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13238     return ;
13239   }
13240   {
13241     try {
13242       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13243     } catch (std::out_of_range& e) {
13244       {
13245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13246       };
13247     } catch (std::exception& e) {
13248       {
13249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13250       };
13251     } catch (Dali::DaliException e) {
13252       {
13253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13254       };
13255     } catch (...) {
13256       {
13257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13258       };
13259     }
13260   }
13261
13262 }
13263
13264
13265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13266   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13267   Dali::Vector3 *arg2 = 0 ;
13268   Dali::Vector3 *arg3 = 0 ;
13269   Dali::Vector3 *arg4 = 0 ;
13270   Dali::Vector3 *arg5 = 0 ;
13271
13272   arg1 = (Dali::Matrix *)jarg1;
13273   arg2 = (Dali::Vector3 *)jarg2;
13274   if (!arg2) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg3 = (Dali::Vector3 *)jarg3;
13279   if (!arg3) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   arg4 = (Dali::Vector3 *)jarg4;
13284   if (!arg4) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13286     return ;
13287   }
13288   arg5 = (Dali::Vector3 *)jarg5;
13289   if (!arg5) {
13290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13291     return ;
13292   }
13293   {
13294     try {
13295       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13296     } catch (std::out_of_range& e) {
13297       {
13298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13299       };
13300     } catch (std::exception& e) {
13301       {
13302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13303       };
13304     } catch (Dali::DaliException e) {
13305       {
13306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13307       };
13308     } catch (...) {
13309       {
13310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13311       };
13312     }
13313   }
13314
13315 }
13316
13317
13318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13319   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13320   Dali::Vector3 *arg2 = 0 ;
13321   Dali::Quaternion *arg3 = 0 ;
13322   Dali::Vector3 *arg4 = 0 ;
13323
13324   arg1 = (Dali::Matrix *)jarg1;
13325   arg2 = (Dali::Vector3 *)jarg2;
13326   if (!arg2) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13328     return ;
13329   }
13330   arg3 = (Dali::Quaternion *)jarg3;
13331   if (!arg3) {
13332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13333     return ;
13334   }
13335   arg4 = (Dali::Vector3 *)jarg4;
13336   if (!arg4) {
13337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13338     return ;
13339   }
13340   {
13341     try {
13342       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13343     } catch (std::out_of_range& e) {
13344       {
13345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13346       };
13347     } catch (std::exception& e) {
13348       {
13349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13350       };
13351     } catch (Dali::DaliException e) {
13352       {
13353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13354       };
13355     } catch (...) {
13356       {
13357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13358       };
13359     }
13360   }
13361
13362 }
13363
13364
13365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13366   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13367
13368   arg1 = (Dali::Matrix *)jarg1;
13369   {
13370     try {
13371       delete arg1;
13372     } catch (std::out_of_range& e) {
13373       {
13374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13375       };
13376     } catch (std::exception& e) {
13377       {
13378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13379       };
13380     } catch (Dali::DaliException e) {
13381       {
13382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13383       };
13384     } catch (...) {
13385       {
13386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13387       };
13388     }
13389   }
13390
13391 }
13392
13393
13394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13395   void * jresult ;
13396   Dali::Matrix3 *result = 0 ;
13397
13398   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13399   jresult = (void *)result;
13400   return jresult;
13401 }
13402
13403
13404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13405   void * jresult ;
13406   Dali::Matrix3 *result = 0 ;
13407
13408   {
13409     try {
13410       result = (Dali::Matrix3 *)new Dali::Matrix3();
13411     } catch (std::out_of_range& e) {
13412       {
13413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13414       };
13415     } catch (std::exception& e) {
13416       {
13417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13418       };
13419     } catch (Dali::DaliException e) {
13420       {
13421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13422       };
13423     } catch (...) {
13424       {
13425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13426       };
13427     }
13428   }
13429
13430   jresult = (void *)result;
13431   return jresult;
13432 }
13433
13434
13435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13436   void * jresult ;
13437   Dali::Matrix3 *arg1 = 0 ;
13438   Dali::Matrix3 *result = 0 ;
13439
13440   arg1 = (Dali::Matrix3 *)jarg1;
13441   if (!arg1) {
13442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13443     return 0;
13444   }
13445   {
13446     try {
13447       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13448     } catch (std::out_of_range& e) {
13449       {
13450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13451       };
13452     } catch (std::exception& e) {
13453       {
13454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13455       };
13456     } catch (Dali::DaliException e) {
13457       {
13458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13459       };
13460     } catch (...) {
13461       {
13462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13463       };
13464     }
13465   }
13466
13467   jresult = (void *)result;
13468   return jresult;
13469 }
13470
13471
13472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13473   void * jresult ;
13474   Dali::Matrix *arg1 = 0 ;
13475   Dali::Matrix3 *result = 0 ;
13476
13477   arg1 = (Dali::Matrix *)jarg1;
13478   if (!arg1) {
13479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13480     return 0;
13481   }
13482   {
13483     try {
13484       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13485     } catch (std::out_of_range& e) {
13486       {
13487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13488       };
13489     } catch (std::exception& e) {
13490       {
13491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13492       };
13493     } catch (Dali::DaliException e) {
13494       {
13495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13496       };
13497     } catch (...) {
13498       {
13499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13500       };
13501     }
13502   }
13503
13504   jresult = (void *)result;
13505   return jresult;
13506 }
13507
13508
13509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13510   void * jresult ;
13511   float arg1 ;
13512   float arg2 ;
13513   float arg3 ;
13514   float arg4 ;
13515   float arg5 ;
13516   float arg6 ;
13517   float arg7 ;
13518   float arg8 ;
13519   float arg9 ;
13520   Dali::Matrix3 *result = 0 ;
13521
13522   arg1 = (float)jarg1;
13523   arg2 = (float)jarg2;
13524   arg3 = (float)jarg3;
13525   arg4 = (float)jarg4;
13526   arg5 = (float)jarg5;
13527   arg6 = (float)jarg6;
13528   arg7 = (float)jarg7;
13529   arg8 = (float)jarg8;
13530   arg9 = (float)jarg9;
13531   {
13532     try {
13533       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13534     } catch (std::out_of_range& e) {
13535       {
13536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13537       };
13538     } catch (std::exception& e) {
13539       {
13540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13541       };
13542     } catch (Dali::DaliException e) {
13543       {
13544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13545       };
13546     } catch (...) {
13547       {
13548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13549       };
13550     }
13551   }
13552
13553   jresult = (void *)result;
13554   return jresult;
13555 }
13556
13557
13558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13559   void * jresult ;
13560   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13561   Dali::Matrix3 *arg2 = 0 ;
13562   Dali::Matrix3 *result = 0 ;
13563
13564   arg1 = (Dali::Matrix3 *)jarg1;
13565   arg2 = (Dali::Matrix3 *)jarg2;
13566   if (!arg2) {
13567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13568     return 0;
13569   }
13570   {
13571     try {
13572       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13573     } catch (std::out_of_range& e) {
13574       {
13575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13576       };
13577     } catch (std::exception& e) {
13578       {
13579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13580       };
13581     } catch (Dali::DaliException e) {
13582       {
13583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13584       };
13585     } catch (...) {
13586       {
13587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13588       };
13589     }
13590   }
13591
13592   jresult = (void *)result;
13593   return jresult;
13594 }
13595
13596
13597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13598   void * jresult ;
13599   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13600   Dali::Matrix *arg2 = 0 ;
13601   Dali::Matrix3 *result = 0 ;
13602
13603   arg1 = (Dali::Matrix3 *)jarg1;
13604   arg2 = (Dali::Matrix *)jarg2;
13605   if (!arg2) {
13606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13607     return 0;
13608   }
13609   {
13610     try {
13611       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13612     } catch (std::out_of_range& e) {
13613       {
13614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13615       };
13616     } catch (std::exception& e) {
13617       {
13618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13619       };
13620     } catch (Dali::DaliException e) {
13621       {
13622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13623       };
13624     } catch (...) {
13625       {
13626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13627       };
13628     }
13629   }
13630
13631   jresult = (void *)result;
13632   return jresult;
13633 }
13634
13635
13636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13637   unsigned int jresult ;
13638   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13639   Dali::Matrix3 *arg2 = 0 ;
13640   bool result;
13641
13642   arg1 = (Dali::Matrix3 *)jarg1;
13643   arg2 = (Dali::Matrix3 *)jarg2;
13644   if (!arg2) {
13645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13646     return 0;
13647   }
13648   {
13649     try {
13650       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13651     } catch (std::out_of_range& e) {
13652       {
13653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13654       };
13655     } catch (std::exception& e) {
13656       {
13657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13658       };
13659     } catch (Dali::DaliException e) {
13660       {
13661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13662       };
13663     } catch (...) {
13664       {
13665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13666       };
13667     }
13668   }
13669
13670   jresult = result;
13671   return jresult;
13672 }
13673
13674
13675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13676   unsigned int jresult ;
13677   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13678   Dali::Matrix3 *arg2 = 0 ;
13679   bool result;
13680
13681   arg1 = (Dali::Matrix3 *)jarg1;
13682   arg2 = (Dali::Matrix3 *)jarg2;
13683   if (!arg2) {
13684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13685     return 0;
13686   }
13687   {
13688     try {
13689       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13690     } catch (std::out_of_range& e) {
13691       {
13692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13693       };
13694     } catch (std::exception& e) {
13695       {
13696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13697       };
13698     } catch (Dali::DaliException e) {
13699       {
13700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13701       };
13702     } catch (...) {
13703       {
13704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13705       };
13706     }
13707   }
13708
13709   jresult = result;
13710   return jresult;
13711 }
13712
13713
13714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13715   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13716
13717   arg1 = (Dali::Matrix3 *)jarg1;
13718   {
13719     try {
13720       delete arg1;
13721     } catch (std::out_of_range& e) {
13722       {
13723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13724       };
13725     } catch (std::exception& e) {
13726       {
13727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13728       };
13729     } catch (Dali::DaliException e) {
13730       {
13731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13732       };
13733     } catch (...) {
13734       {
13735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13736       };
13737     }
13738   }
13739
13740 }
13741
13742
13743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13744   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13745
13746   arg1 = (Dali::Matrix3 *)jarg1;
13747   {
13748     try {
13749       (arg1)->SetIdentity();
13750     } catch (std::out_of_range& e) {
13751       {
13752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13753       };
13754     } catch (std::exception& e) {
13755       {
13756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13757       };
13758     } catch (Dali::DaliException e) {
13759       {
13760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13761       };
13762     } catch (...) {
13763       {
13764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13765       };
13766     }
13767   }
13768
13769 }
13770
13771
13772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13773   void * jresult ;
13774   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13775   float *result = 0 ;
13776
13777   arg1 = (Dali::Matrix3 *)jarg1;
13778   {
13779     try {
13780       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13781     } catch (std::out_of_range& e) {
13782       {
13783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13784       };
13785     } catch (std::exception& e) {
13786       {
13787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13788       };
13789     } catch (Dali::DaliException e) {
13790       {
13791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13792       };
13793     } catch (...) {
13794       {
13795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13796       };
13797     }
13798   }
13799
13800   jresult = (void *)result;
13801   return jresult;
13802 }
13803
13804
13805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13806   unsigned int jresult ;
13807   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13808   bool result;
13809
13810   arg1 = (Dali::Matrix3 *)jarg1;
13811   {
13812     try {
13813       result = (bool)(arg1)->Invert();
13814     } catch (std::out_of_range& e) {
13815       {
13816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13817       };
13818     } catch (std::exception& e) {
13819       {
13820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13821       };
13822     } catch (Dali::DaliException e) {
13823       {
13824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13825       };
13826     } catch (...) {
13827       {
13828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13829       };
13830     }
13831   }
13832
13833   jresult = result;
13834   return jresult;
13835 }
13836
13837
13838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13839   unsigned int jresult ;
13840   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13841   bool result;
13842
13843   arg1 = (Dali::Matrix3 *)jarg1;
13844   {
13845     try {
13846       result = (bool)(arg1)->Transpose();
13847     } catch (std::out_of_range& e) {
13848       {
13849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13850       };
13851     } catch (std::exception& e) {
13852       {
13853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (Dali::DaliException e) {
13856       {
13857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865
13866   jresult = result;
13867   return jresult;
13868 }
13869
13870
13871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13872   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13873   float arg2 ;
13874
13875   arg1 = (Dali::Matrix3 *)jarg1;
13876   arg2 = (float)jarg2;
13877   {
13878     try {
13879       (arg1)->Scale(arg2);
13880     } catch (std::out_of_range& e) {
13881       {
13882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13883       };
13884     } catch (std::exception& e) {
13885       {
13886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13887       };
13888     } catch (Dali::DaliException e) {
13889       {
13890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13895       };
13896     }
13897   }
13898
13899 }
13900
13901
13902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13903   float jresult ;
13904   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13905   float result;
13906
13907   arg1 = (Dali::Matrix3 *)jarg1;
13908   {
13909     try {
13910       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13911     } catch (std::out_of_range& e) {
13912       {
13913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13914       };
13915     } catch (std::exception& e) {
13916       {
13917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13918       };
13919     } catch (Dali::DaliException e) {
13920       {
13921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13922       };
13923     } catch (...) {
13924       {
13925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13926       };
13927     }
13928   }
13929
13930   jresult = result;
13931   return jresult;
13932 }
13933
13934
13935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13936   unsigned int jresult ;
13937   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13938   bool result;
13939
13940   arg1 = (Dali::Matrix3 *)jarg1;
13941   {
13942     try {
13943       result = (bool)(arg1)->ScaledInverseTranspose();
13944     } catch (std::out_of_range& e) {
13945       {
13946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13947       };
13948     } catch (std::exception& e) {
13949       {
13950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13951       };
13952     } catch (Dali::DaliException e) {
13953       {
13954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13955       };
13956     } catch (...) {
13957       {
13958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13959       };
13960     }
13961   }
13962
13963   jresult = result;
13964   return jresult;
13965 }
13966
13967
13968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13969   Dali::Matrix3 *arg1 = 0 ;
13970   Dali::Matrix3 *arg2 = 0 ;
13971   Dali::Matrix3 *arg3 = 0 ;
13972
13973   arg1 = (Dali::Matrix3 *)jarg1;
13974   if (!arg1) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13976     return ;
13977   }
13978   arg2 = (Dali::Matrix3 *)jarg2;
13979   if (!arg2) {
13980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13981     return ;
13982   }
13983   arg3 = (Dali::Matrix3 *)jarg3;
13984   if (!arg3) {
13985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13986     return ;
13987   }
13988   {
13989     try {
13990       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13991     } catch (std::out_of_range& e) {
13992       {
13993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13994       };
13995     } catch (std::exception& e) {
13996       {
13997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13998       };
13999     } catch (Dali::DaliException e) {
14000       {
14001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14002       };
14003     } catch (...) {
14004       {
14005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14006       };
14007     }
14008   }
14009
14010 }
14011
14012
14013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14014   float jresult ;
14015   float arg1 ;
14016   float arg2 ;
14017   float result;
14018
14019   arg1 = (float)jarg1;
14020   arg2 = (float)jarg2;
14021   {
14022     try {
14023       result = (float)Dali::Random::Range(arg1,arg2);
14024     } catch (std::out_of_range& e) {
14025       {
14026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (std::exception& e) {
14029       {
14030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14031       };
14032     } catch (Dali::DaliException e) {
14033       {
14034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14035       };
14036     } catch (...) {
14037       {
14038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14039       };
14040     }
14041   }
14042
14043   jresult = result;
14044   return jresult;
14045 }
14046
14047
14048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14049   void * jresult ;
14050   Dali::Vector4 result;
14051
14052   {
14053     try {
14054       result = Dali::Random::Axis();
14055     } catch (std::out_of_range& e) {
14056       {
14057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14058       };
14059     } catch (std::exception& e) {
14060       {
14061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14062       };
14063     } catch (Dali::DaliException e) {
14064       {
14065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14066       };
14067     } catch (...) {
14068       {
14069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14070       };
14071     }
14072   }
14073
14074   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14075   return jresult;
14076 }
14077
14078
14079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14080   void * jresult ;
14081   Dali::AngleAxis *result = 0 ;
14082
14083   {
14084     try {
14085       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14086     } catch (std::out_of_range& e) {
14087       {
14088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (std::exception& e) {
14091       {
14092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14093       };
14094     } catch (Dali::DaliException e) {
14095       {
14096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14097       };
14098     } catch (...) {
14099       {
14100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14101       };
14102     }
14103   }
14104
14105   jresult = (void *)result;
14106   return jresult;
14107 }
14108
14109
14110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14111   void * jresult ;
14112   Dali::Radian arg1 ;
14113   Dali::Vector3 *arg2 = 0 ;
14114   Dali::Radian *argp1 ;
14115   Dali::AngleAxis *result = 0 ;
14116
14117   argp1 = (Dali::Radian *)jarg1;
14118   if (!argp1) {
14119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14120     return 0;
14121   }
14122   arg1 = *argp1;
14123   arg2 = (Dali::Vector3 *)jarg2;
14124   if (!arg2) {
14125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14126     return 0;
14127   }
14128   {
14129     try {
14130       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14131     } catch (std::out_of_range& e) {
14132       {
14133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14134       };
14135     } catch (std::exception& e) {
14136       {
14137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14138       };
14139     } catch (Dali::DaliException e) {
14140       {
14141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14142       };
14143     } catch (...) {
14144       {
14145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14146       };
14147     }
14148   }
14149
14150   jresult = (void *)result;
14151   return jresult;
14152 }
14153
14154
14155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14156   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14157   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14158
14159   arg1 = (Dali::AngleAxis *)jarg1;
14160   arg2 = (Dali::Radian *)jarg2;
14161   if (arg1) (arg1)->angle = *arg2;
14162 }
14163
14164
14165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14166   void * jresult ;
14167   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14168   Dali::Radian *result = 0 ;
14169
14170   arg1 = (Dali::AngleAxis *)jarg1;
14171   result = (Dali::Radian *)& ((arg1)->angle);
14172   jresult = (void *)result;
14173   return jresult;
14174 }
14175
14176
14177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14178   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14179   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14180
14181   arg1 = (Dali::AngleAxis *)jarg1;
14182   arg2 = (Dali::Vector3 *)jarg2;
14183   if (arg1) (arg1)->axis = *arg2;
14184 }
14185
14186
14187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14188   void * jresult ;
14189   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14190   Dali::Vector3 *result = 0 ;
14191
14192   arg1 = (Dali::AngleAxis *)jarg1;
14193   result = (Dali::Vector3 *)& ((arg1)->axis);
14194   jresult = (void *)result;
14195   return jresult;
14196 }
14197
14198
14199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14200   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14201
14202   arg1 = (Dali::AngleAxis *)jarg1;
14203   {
14204     try {
14205       delete arg1;
14206     } catch (std::out_of_range& e) {
14207       {
14208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14209       };
14210     } catch (std::exception& e) {
14211       {
14212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14213       };
14214     } catch (Dali::DaliException e) {
14215       {
14216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14217       };
14218     } catch (...) {
14219       {
14220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14221       };
14222     }
14223   }
14224
14225 }
14226
14227
14228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14229   unsigned int jresult ;
14230   Dali::AngleAxis *arg1 = 0 ;
14231   Dali::AngleAxis *arg2 = 0 ;
14232   bool result;
14233
14234   arg1 = (Dali::AngleAxis *)jarg1;
14235   if (!arg1) {
14236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14237     return 0;
14238   }
14239   arg2 = (Dali::AngleAxis *)jarg2;
14240   if (!arg2) {
14241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14242     return 0;
14243   }
14244   {
14245     try {
14246       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14247     } catch (std::out_of_range& e) {
14248       {
14249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14250       };
14251     } catch (std::exception& e) {
14252       {
14253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14254       };
14255     } catch (Dali::DaliException e) {
14256       {
14257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14258       };
14259     } catch (...) {
14260       {
14261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14262       };
14263     }
14264   }
14265
14266   jresult = result;
14267   return jresult;
14268 }
14269
14270
14271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14272   unsigned int jresult ;
14273   unsigned int arg1 ;
14274   unsigned int result;
14275
14276   arg1 = (unsigned int)jarg1;
14277   {
14278     try {
14279       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14280     } catch (std::out_of_range& e) {
14281       {
14282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (std::exception& e) {
14285       {
14286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14287       };
14288     } catch (Dali::DaliException e) {
14289       {
14290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14291       };
14292     } catch (...) {
14293       {
14294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14295       };
14296     }
14297   }
14298
14299   jresult = result;
14300   return jresult;
14301 }
14302
14303
14304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14305   unsigned int jresult ;
14306   unsigned int arg1 ;
14307   bool result;
14308
14309   arg1 = (unsigned int)jarg1;
14310   {
14311     try {
14312       result = (bool)Dali::IsPowerOfTwo(arg1);
14313     } catch (std::out_of_range& e) {
14314       {
14315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14316       };
14317     } catch (std::exception& e) {
14318       {
14319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14320       };
14321     } catch (Dali::DaliException e) {
14322       {
14323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14324       };
14325     } catch (...) {
14326       {
14327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14328       };
14329     }
14330   }
14331
14332   jresult = result;
14333   return jresult;
14334 }
14335
14336
14337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14338   float jresult ;
14339   float arg1 ;
14340   float arg2 ;
14341   float result;
14342
14343   arg1 = (float)jarg1;
14344   arg2 = (float)jarg2;
14345   {
14346     try {
14347       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14348     } catch (std::out_of_range& e) {
14349       {
14350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14351       };
14352     } catch (std::exception& e) {
14353       {
14354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14355       };
14356     } catch (Dali::DaliException e) {
14357       {
14358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14359       };
14360     } catch (...) {
14361       {
14362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14363       };
14364     }
14365   }
14366
14367   jresult = result;
14368   return jresult;
14369 }
14370
14371
14372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14373   unsigned int jresult ;
14374   float arg1 ;
14375   bool result;
14376
14377   arg1 = (float)jarg1;
14378   {
14379     try {
14380       result = (bool)Dali::EqualsZero(arg1);
14381     } catch (std::out_of_range& e) {
14382       {
14383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14384       };
14385     } catch (std::exception& e) {
14386       {
14387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (Dali::DaliException e) {
14390       {
14391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399
14400   jresult = result;
14401   return jresult;
14402 }
14403
14404
14405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14406   unsigned int jresult ;
14407   float arg1 ;
14408   float arg2 ;
14409   bool result;
14410
14411   arg1 = (float)jarg1;
14412   arg2 = (float)jarg2;
14413   {
14414     try {
14415       result = (bool)Dali::Equals(arg1,arg2);
14416     } catch (std::out_of_range& e) {
14417       {
14418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14419       };
14420     } catch (std::exception& e) {
14421       {
14422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14423       };
14424     } catch (Dali::DaliException e) {
14425       {
14426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14427       };
14428     } catch (...) {
14429       {
14430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14431       };
14432     }
14433   }
14434
14435   jresult = result;
14436   return jresult;
14437 }
14438
14439
14440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14441   unsigned int jresult ;
14442   float arg1 ;
14443   float arg2 ;
14444   float arg3 ;
14445   bool result;
14446
14447   arg1 = (float)jarg1;
14448   arg2 = (float)jarg2;
14449   arg3 = (float)jarg3;
14450   {
14451     try {
14452       result = (bool)Dali::Equals(arg1,arg2,arg3);
14453     } catch (std::out_of_range& e) {
14454       {
14455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14456       };
14457     } catch (std::exception& e) {
14458       {
14459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14460       };
14461     } catch (Dali::DaliException e) {
14462       {
14463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14464       };
14465     } catch (...) {
14466       {
14467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14468       };
14469     }
14470   }
14471
14472   jresult = result;
14473   return jresult;
14474 }
14475
14476
14477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14478   float jresult ;
14479   float arg1 ;
14480   int arg2 ;
14481   float result;
14482
14483   arg1 = (float)jarg1;
14484   arg2 = (int)jarg2;
14485   {
14486     try {
14487       result = (float)Dali::Round(arg1,arg2);
14488     } catch (std::out_of_range& e) {
14489       {
14490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14491       };
14492     } catch (std::exception& e) {
14493       {
14494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14495       };
14496     } catch (Dali::DaliException e) {
14497       {
14498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14499       };
14500     } catch (...) {
14501       {
14502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14503       };
14504     }
14505   }
14506
14507   jresult = result;
14508   return jresult;
14509 }
14510
14511
14512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14513   float jresult ;
14514   float arg1 ;
14515   float arg2 ;
14516   float arg3 ;
14517   float result;
14518
14519   arg1 = (float)jarg1;
14520   arg2 = (float)jarg2;
14521   arg3 = (float)jarg3;
14522   {
14523     try {
14524       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14525     } catch (std::out_of_range& e) {
14526       {
14527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14528       };
14529     } catch (std::exception& e) {
14530       {
14531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14532       };
14533     } catch (Dali::DaliException e) {
14534       {
14535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14536       };
14537     } catch (...) {
14538       {
14539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14540       };
14541     }
14542   }
14543
14544   jresult = result;
14545   return jresult;
14546 }
14547
14548
14549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14550   float jresult ;
14551   float arg1 ;
14552   float arg2 ;
14553   float arg3 ;
14554   float arg4 ;
14555   float result;
14556
14557   arg1 = (float)jarg1;
14558   arg2 = (float)jarg2;
14559   arg3 = (float)jarg3;
14560   arg4 = (float)jarg4;
14561   {
14562     try {
14563       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14564     } catch (std::out_of_range& e) {
14565       {
14566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14567       };
14568     } catch (std::exception& e) {
14569       {
14570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14571       };
14572     } catch (Dali::DaliException e) {
14573       {
14574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14575       };
14576     } catch (...) {
14577       {
14578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14579       };
14580     }
14581   }
14582
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14589   int jresult ;
14590   int result;
14591
14592   result = (int)(int)Dali::Property::INVALID_INDEX;
14593   jresult = result;
14594   return jresult;
14595 }
14596
14597
14598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14599   int jresult ;
14600   int result;
14601
14602   result = (int)(int)Dali::Property::INVALID_KEY;
14603   jresult = result;
14604   return jresult;
14605 }
14606
14607
14608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14609   int jresult ;
14610   int result;
14611
14612   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14613   jresult = result;
14614   return jresult;
14615 }
14616
14617
14618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14619   void * jresult ;
14620   Dali::Handle *arg1 = 0 ;
14621   Dali::Property::Index arg2 ;
14622   Dali::Property *result = 0 ;
14623
14624   arg1 = (Dali::Handle *)jarg1;
14625   if (!arg1) {
14626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14627     return 0;
14628   }
14629   arg2 = (Dali::Property::Index)jarg2;
14630   {
14631     try {
14632       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14633     } catch (std::out_of_range& e) {
14634       {
14635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14636       };
14637     } catch (std::exception& e) {
14638       {
14639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14640       };
14641     } catch (Dali::DaliException e) {
14642       {
14643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14644       };
14645     } catch (...) {
14646       {
14647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14648       };
14649     }
14650   }
14651
14652   jresult = (void *)result;
14653   return jresult;
14654 }
14655
14656
14657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14658   void * jresult ;
14659   Dali::Handle *arg1 = 0 ;
14660   Dali::Property::Index arg2 ;
14661   int arg3 ;
14662   Dali::Property *result = 0 ;
14663
14664   arg1 = (Dali::Handle *)jarg1;
14665   if (!arg1) {
14666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14667     return 0;
14668   }
14669   arg2 = (Dali::Property::Index)jarg2;
14670   arg3 = (int)jarg3;
14671   {
14672     try {
14673       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14674     } catch (std::out_of_range& e) {
14675       {
14676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (std::exception& e) {
14679       {
14680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14681       };
14682     } catch (Dali::DaliException e) {
14683       {
14684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14685       };
14686     } catch (...) {
14687       {
14688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14689       };
14690     }
14691   }
14692
14693   jresult = (void *)result;
14694   return jresult;
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14699   void * jresult ;
14700   Dali::Handle *arg1 = 0 ;
14701   std::string *arg2 = 0 ;
14702   Dali::Property *result = 0 ;
14703
14704   arg1 = (Dali::Handle *)jarg1;
14705   if (!arg1) {
14706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14707     return 0;
14708   }
14709   if (!jarg2) {
14710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14711     return 0;
14712   }
14713   std::string arg2_str(jarg2);
14714   arg2 = &arg2_str;
14715   {
14716     try {
14717       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14718     } catch (std::out_of_range& e) {
14719       {
14720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14721       };
14722     } catch (std::exception& e) {
14723       {
14724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14725       };
14726     } catch (Dali::DaliException e) {
14727       {
14728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14729       };
14730     } catch (...) {
14731       {
14732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14733       };
14734     }
14735   }
14736
14737   jresult = (void *)result;
14738
14739   //argout typemap for const std::string&
14740
14741   return jresult;
14742 }
14743
14744
14745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14746   void * jresult ;
14747   Dali::Handle *arg1 = 0 ;
14748   std::string *arg2 = 0 ;
14749   int arg3 ;
14750   Dali::Property *result = 0 ;
14751
14752   arg1 = (Dali::Handle *)jarg1;
14753   if (!arg1) {
14754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14755     return 0;
14756   }
14757   if (!jarg2) {
14758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14759     return 0;
14760   }
14761   std::string arg2_str(jarg2);
14762   arg2 = &arg2_str;
14763   arg3 = (int)jarg3;
14764   {
14765     try {
14766       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14767     } catch (std::out_of_range& e) {
14768       {
14769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (std::exception& e) {
14772       {
14773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14774       };
14775     } catch (Dali::DaliException e) {
14776       {
14777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14778       };
14779     } catch (...) {
14780       {
14781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14782       };
14783     }
14784   }
14785
14786   jresult = (void *)result;
14787
14788   //argout typemap for const std::string&
14789
14790   return jresult;
14791 }
14792
14793
14794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14795   Dali::Property *arg1 = (Dali::Property *) 0 ;
14796
14797   arg1 = (Dali::Property *)jarg1;
14798   {
14799     try {
14800       delete arg1;
14801     } catch (std::out_of_range& e) {
14802       {
14803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14804       };
14805     } catch (std::exception& e) {
14806       {
14807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14808       };
14809     } catch (Dali::DaliException e) {
14810       {
14811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14812       };
14813     } catch (...) {
14814       {
14815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14816       };
14817     }
14818   }
14819
14820 }
14821
14822
14823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14824   Dali::Property *arg1 = (Dali::Property *) 0 ;
14825   Dali::Handle *arg2 = 0 ;
14826
14827   arg1 = (Dali::Property *)jarg1;
14828   arg2 = (Dali::Handle *)jarg2;
14829   if (!arg2) {
14830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14831     return ;
14832   }
14833   if (arg1) (arg1)->object = *arg2;
14834 }
14835
14836
14837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14838   void * jresult ;
14839   Dali::Property *arg1 = (Dali::Property *) 0 ;
14840   Dali::Handle *result = 0 ;
14841
14842   arg1 = (Dali::Property *)jarg1;
14843   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14844   jresult = (void *)result;
14845   return jresult;
14846 }
14847
14848
14849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14850   Dali::Property *arg1 = (Dali::Property *) 0 ;
14851   Dali::Property::Index arg2 ;
14852
14853   arg1 = (Dali::Property *)jarg1;
14854   arg2 = (Dali::Property::Index)jarg2;
14855   if (arg1) (arg1)->propertyIndex = arg2;
14856 }
14857
14858
14859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14860   int jresult ;
14861   Dali::Property *arg1 = (Dali::Property *) 0 ;
14862   Dali::Property::Index result;
14863
14864   arg1 = (Dali::Property *)jarg1;
14865   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14866   jresult = result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14872   Dali::Property *arg1 = (Dali::Property *) 0 ;
14873   int arg2 ;
14874
14875   arg1 = (Dali::Property *)jarg1;
14876   arg2 = (int)jarg2;
14877   if (arg1) (arg1)->componentIndex = arg2;
14878 }
14879
14880
14881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14882   int jresult ;
14883   Dali::Property *arg1 = (Dali::Property *) 0 ;
14884   int result;
14885
14886   arg1 = (Dali::Property *)jarg1;
14887   result = (int) ((arg1)->componentIndex);
14888   jresult = result;
14889   return jresult;
14890 }
14891
14892
14893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14894   void * jresult ;
14895   Dali::Property::Array *result = 0 ;
14896
14897   {
14898     try {
14899       result = (Dali::Property::Array *)new Dali::Property::Array();
14900     } catch (std::out_of_range& e) {
14901       {
14902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14903       };
14904     } catch (std::exception& e) {
14905       {
14906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14907       };
14908     } catch (Dali::DaliException e) {
14909       {
14910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14911       };
14912     } catch (...) {
14913       {
14914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14915       };
14916     }
14917   }
14918
14919   jresult = (void *)result;
14920   return jresult;
14921 }
14922
14923
14924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14925   void * jresult ;
14926   Dali::Property::Array *arg1 = 0 ;
14927   Dali::Property::Array *result = 0 ;
14928
14929   arg1 = (Dali::Property::Array *)jarg1;
14930   if (!arg1) {
14931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14932     return 0;
14933   }
14934   {
14935     try {
14936       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14937     } catch (std::out_of_range& e) {
14938       {
14939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14940       };
14941     } catch (std::exception& e) {
14942       {
14943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14944       };
14945     } catch (Dali::DaliException e) {
14946       {
14947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14948       };
14949     } catch (...) {
14950       {
14951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14952       };
14953     }
14954   }
14955
14956   jresult = (void *)result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14962   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14963
14964   arg1 = (Dali::Property::Array *)jarg1;
14965   {
14966     try {
14967       delete arg1;
14968     } catch (std::out_of_range& e) {
14969       {
14970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14971       };
14972     } catch (std::exception& e) {
14973       {
14974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14975       };
14976     } catch (Dali::DaliException e) {
14977       {
14978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14979       };
14980     } catch (...) {
14981       {
14982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14983       };
14984     }
14985   }
14986
14987 }
14988
14989
14990 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14991   unsigned long jresult ;
14992   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14993   Dali::Property::Array::SizeType result;
14994
14995   arg1 = (Dali::Property::Array *)jarg1;
14996   {
14997     try {
14998       result = ((Dali::Property::Array const *)arg1)->Size();
14999     } catch (std::out_of_range& e) {
15000       {
15001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15002       };
15003     } catch (std::exception& e) {
15004       {
15005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15006       };
15007     } catch (Dali::DaliException e) {
15008       {
15009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15010       };
15011     } catch (...) {
15012       {
15013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15014       };
15015     }
15016   }
15017
15018   jresult = (unsigned long)result;
15019   return jresult;
15020 }
15021
15022
15023 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15024   unsigned long jresult ;
15025   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15026   Dali::Property::Array::SizeType result;
15027
15028   arg1 = (Dali::Property::Array *)jarg1;
15029   {
15030     try {
15031       result = ((Dali::Property::Array const *)arg1)->Count();
15032     } catch (std::out_of_range& e) {
15033       {
15034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15035       };
15036     } catch (std::exception& e) {
15037       {
15038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15039       };
15040     } catch (Dali::DaliException e) {
15041       {
15042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15043       };
15044     } catch (...) {
15045       {
15046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15047       };
15048     }
15049   }
15050
15051   jresult = (unsigned long)result;
15052   return jresult;
15053 }
15054
15055
15056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15057   unsigned int jresult ;
15058   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15059   bool result;
15060
15061   arg1 = (Dali::Property::Array *)jarg1;
15062   {
15063     try {
15064       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15065     } catch (std::out_of_range& e) {
15066       {
15067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15068       };
15069     } catch (std::exception& e) {
15070       {
15071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15072       };
15073     } catch (Dali::DaliException e) {
15074       {
15075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15076       };
15077     } catch (...) {
15078       {
15079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15080       };
15081     }
15082   }
15083
15084   jresult = result;
15085   return jresult;
15086 }
15087
15088
15089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15090   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15091
15092   arg1 = (Dali::Property::Array *)jarg1;
15093   {
15094     try {
15095       (arg1)->Clear();
15096     } catch (std::out_of_range& e) {
15097       {
15098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15099       };
15100     } catch (std::exception& e) {
15101       {
15102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15103       };
15104     } catch (Dali::DaliException e) {
15105       {
15106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15107       };
15108     } catch (...) {
15109       {
15110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15111       };
15112     }
15113   }
15114
15115 }
15116
15117
15118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15119   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15120   Dali::Property::Array::SizeType arg2 ;
15121
15122   arg1 = (Dali::Property::Array *)jarg1;
15123   arg2 = (Dali::Property::Array::SizeType)jarg2;
15124   {
15125     try {
15126       (arg1)->Reserve(arg2);
15127     } catch (std::out_of_range& e) {
15128       {
15129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15130       };
15131     } catch (std::exception& e) {
15132       {
15133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15134       };
15135     } catch (Dali::DaliException e) {
15136       {
15137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15142       };
15143     }
15144   }
15145
15146 }
15147
15148
15149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15150   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15151   Dali::Property::Array::SizeType arg2 ;
15152
15153   arg1 = (Dali::Property::Array *)jarg1;
15154   arg2 = (Dali::Property::Array::SizeType)jarg2;
15155   {
15156     try {
15157       (arg1)->Resize(arg2);
15158     } catch (std::out_of_range& e) {
15159       {
15160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15161       };
15162     } catch (std::exception& e) {
15163       {
15164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15165       };
15166     } catch (Dali::DaliException e) {
15167       {
15168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15169       };
15170     } catch (...) {
15171       {
15172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15173       };
15174     }
15175   }
15176
15177 }
15178
15179
15180 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15181   unsigned long jresult ;
15182   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15183   Dali::Property::Array::SizeType result;
15184
15185   arg1 = (Dali::Property::Array *)jarg1;
15186   {
15187     try {
15188       result = (arg1)->Capacity();
15189     } catch (std::out_of_range& e) {
15190       {
15191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15192       };
15193     } catch (std::exception& e) {
15194       {
15195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15196       };
15197     } catch (Dali::DaliException e) {
15198       {
15199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15200       };
15201     } catch (...) {
15202       {
15203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15204       };
15205     }
15206   }
15207
15208   jresult = (unsigned long)result;
15209   return jresult;
15210 }
15211
15212
15213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15214   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15215   Dali::Property::Value *arg2 = 0 ;
15216
15217   arg1 = (Dali::Property::Array *)jarg1;
15218   arg2 = (Dali::Property::Value *)jarg2;
15219   if (!arg2) {
15220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15221     return ;
15222   }
15223   {
15224     try {
15225       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15226     } catch (std::out_of_range& e) {
15227       {
15228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15229       };
15230     } catch (std::exception& e) {
15231       {
15232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15233       };
15234     } catch (Dali::DaliException e) {
15235       {
15236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15237       };
15238     } catch (...) {
15239       {
15240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15241       };
15242     }
15243   }
15244
15245 }
15246
15247
15248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15249   void * jresult ;
15250   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15251   Dali::Property::Value *arg2 = 0 ;
15252   Dali::Property::Array *result = 0 ;
15253
15254   arg1 = (Dali::Property::Array *)jarg1;
15255   arg2 = (Dali::Property::Value *)jarg2;
15256   if (!arg2) {
15257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15258     return 0;
15259   }
15260   {
15261     try {
15262       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15263     } catch (std::out_of_range& e) {
15264       {
15265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15266       };
15267     } catch (std::exception& e) {
15268       {
15269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15270       };
15271     } catch (Dali::DaliException e) {
15272       {
15273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15274       };
15275     } catch (...) {
15276       {
15277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15278       };
15279     }
15280   }
15281
15282   jresult = (void *)result;
15283   return jresult;
15284 }
15285
15286
15287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15288   void * jresult ;
15289   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15290   Dali::Property::Array::SizeType arg2 ;
15291   Dali::Property::Value *result = 0 ;
15292
15293   arg1 = (Dali::Property::Array *)jarg1;
15294   arg2 = (Dali::Property::Array::SizeType)jarg2;
15295   {
15296     try {
15297       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15298     } catch (std::out_of_range& e) {
15299       {
15300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15301       };
15302     } catch (std::exception& e) {
15303       {
15304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15305       };
15306     } catch (Dali::DaliException e) {
15307       {
15308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15309       };
15310     } catch (...) {
15311       {
15312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15313       };
15314     }
15315   }
15316
15317   jresult = (void *)result;
15318   return jresult;
15319 }
15320
15321
15322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15323   void * jresult ;
15324   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15325   Dali::Property::Array::SizeType arg2 ;
15326   Dali::Property::Value *result = 0 ;
15327
15328   arg1 = (Dali::Property::Array *)jarg1;
15329   arg2 = (Dali::Property::Array::SizeType)jarg2;
15330   {
15331     try {
15332       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15333     } catch (std::out_of_range& e) {
15334       {
15335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15336       };
15337     } catch (std::exception& e) {
15338       {
15339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15340       };
15341     } catch (Dali::DaliException e) {
15342       {
15343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15344       };
15345     } catch (...) {
15346       {
15347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15348       };
15349     }
15350   }
15351
15352   jresult = (void *)result;
15353   return jresult;
15354 }
15355
15356
15357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15358   void * jresult ;
15359   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15360   Dali::Property::Array *arg2 = 0 ;
15361   Dali::Property::Array *result = 0 ;
15362
15363   arg1 = (Dali::Property::Array *)jarg1;
15364   arg2 = (Dali::Property::Array *)jarg2;
15365   if (!arg2) {
15366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15367     return 0;
15368   }
15369   {
15370     try {
15371       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15372     } catch (std::out_of_range& e) {
15373       {
15374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15375       };
15376     } catch (std::exception& e) {
15377       {
15378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15379       };
15380     } catch (Dali::DaliException e) {
15381       {
15382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15383       };
15384     } catch (...) {
15385       {
15386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15387       };
15388     }
15389   }
15390
15391   jresult = (void *)result;
15392   return jresult;
15393 }
15394
15395
15396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15397   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15398   enum Dali::Property::Key::Type arg2 ;
15399
15400   arg1 = (Dali::Property::Key *)jarg1;
15401   arg2 = (enum Dali::Property::Key::Type)jarg2;
15402   if (arg1) (arg1)->type = arg2;
15403 }
15404
15405
15406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15407   int jresult ;
15408   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15409   enum Dali::Property::Key::Type result;
15410
15411   arg1 = (Dali::Property::Key *)jarg1;
15412   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15413   jresult = (int)result;
15414   return jresult;
15415 }
15416
15417
15418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15419   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15420   Dali::Property::Index arg2 ;
15421
15422   arg1 = (Dali::Property::Key *)jarg1;
15423   arg2 = (Dali::Property::Index)jarg2;
15424   if (arg1) (arg1)->indexKey = arg2;
15425 }
15426
15427
15428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15429   int jresult ;
15430   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15431   Dali::Property::Index result;
15432
15433   arg1 = (Dali::Property::Key *)jarg1;
15434   result = (Dali::Property::Index) ((arg1)->indexKey);
15435   jresult = result;
15436   return jresult;
15437 }
15438
15439
15440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15441   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15442   std::string *arg2 = 0 ;
15443
15444   arg1 = (Dali::Property::Key *)jarg1;
15445   if (!jarg2) {
15446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15447     return ;
15448   }
15449   std::string arg2_str(jarg2);
15450   arg2 = &arg2_str;
15451   if (arg1) (arg1)->stringKey = *arg2;
15452
15453   //argout typemap for const std::string&
15454
15455 }
15456
15457
15458 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15459   char * jresult ;
15460   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15461   std::string *result = 0 ;
15462
15463   arg1 = (Dali::Property::Key *)jarg1;
15464   result = (std::string *) & ((arg1)->stringKey);
15465   jresult = SWIG_csharp_string_callback(result->c_str());
15466   return jresult;
15467 }
15468
15469
15470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15471   void * jresult ;
15472   std::string *arg1 = 0 ;
15473   Dali::Property::Key *result = 0 ;
15474
15475   if (!jarg1) {
15476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15477     return 0;
15478   }
15479   std::string arg1_str(jarg1);
15480   arg1 = &arg1_str;
15481   {
15482     try {
15483       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15484     } catch (std::out_of_range& e) {
15485       {
15486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15487       };
15488     } catch (std::exception& e) {
15489       {
15490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15491       };
15492     } catch (Dali::DaliException e) {
15493       {
15494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15495       };
15496     } catch (...) {
15497       {
15498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15499       };
15500     }
15501   }
15502
15503   jresult = (void *)result;
15504
15505   //argout typemap for const std::string&
15506
15507   return jresult;
15508 }
15509
15510
15511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15512   void * jresult ;
15513   Dali::Property::Index arg1 ;
15514   Dali::Property::Key *result = 0 ;
15515
15516   arg1 = (Dali::Property::Index)jarg1;
15517   {
15518     try {
15519       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15520     } catch (std::out_of_range& e) {
15521       {
15522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (std::exception& e) {
15525       {
15526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15527       };
15528     } catch (Dali::DaliException e) {
15529       {
15530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15531       };
15532     } catch (...) {
15533       {
15534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15535       };
15536     }
15537   }
15538
15539   jresult = (void *)result;
15540   return jresult;
15541 }
15542
15543
15544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15545   unsigned int jresult ;
15546   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15547   std::string *arg2 = 0 ;
15548   bool result;
15549
15550   arg1 = (Dali::Property::Key *)jarg1;
15551   if (!jarg2) {
15552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15553     return 0;
15554   }
15555   std::string arg2_str(jarg2);
15556   arg2 = &arg2_str;
15557   {
15558     try {
15559       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15560     } catch (std::out_of_range& e) {
15561       {
15562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15563       };
15564     } catch (std::exception& e) {
15565       {
15566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15567       };
15568     } catch (Dali::DaliException e) {
15569       {
15570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15571       };
15572     } catch (...) {
15573       {
15574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15575       };
15576     }
15577   }
15578
15579   jresult = result;
15580
15581   //argout typemap for const std::string&
15582
15583   return jresult;
15584 }
15585
15586
15587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15588   unsigned int jresult ;
15589   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15590   Dali::Property::Index arg2 ;
15591   bool result;
15592
15593   arg1 = (Dali::Property::Key *)jarg1;
15594   arg2 = (Dali::Property::Index)jarg2;
15595   {
15596     try {
15597       result = (bool)(arg1)->operator ==(arg2);
15598     } catch (std::out_of_range& e) {
15599       {
15600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15601       };
15602     } catch (std::exception& e) {
15603       {
15604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15605       };
15606     } catch (Dali::DaliException e) {
15607       {
15608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15609       };
15610     } catch (...) {
15611       {
15612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15613       };
15614     }
15615   }
15616
15617   jresult = result;
15618   return jresult;
15619 }
15620
15621
15622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15623   unsigned int jresult ;
15624   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15625   Dali::Property::Key *arg2 = 0 ;
15626   bool result;
15627
15628   arg1 = (Dali::Property::Key *)jarg1;
15629   arg2 = (Dali::Property::Key *)jarg2;
15630   if (!arg2) {
15631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15632     return 0;
15633   }
15634   {
15635     try {
15636       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15637     } catch (std::out_of_range& e) {
15638       {
15639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15640       };
15641     } catch (std::exception& e) {
15642       {
15643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15644       };
15645     } catch (Dali::DaliException e) {
15646       {
15647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15648       };
15649     } catch (...) {
15650       {
15651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15652       };
15653     }
15654   }
15655
15656   jresult = result;
15657   return jresult;
15658 }
15659
15660
15661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15662   unsigned int jresult ;
15663   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15664   std::string *arg2 = 0 ;
15665   bool result;
15666
15667   arg1 = (Dali::Property::Key *)jarg1;
15668   if (!jarg2) {
15669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15670     return 0;
15671   }
15672   std::string arg2_str(jarg2);
15673   arg2 = &arg2_str;
15674   {
15675     try {
15676       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15677     } catch (std::out_of_range& e) {
15678       {
15679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15680       };
15681     } catch (std::exception& e) {
15682       {
15683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15684       };
15685     } catch (Dali::DaliException e) {
15686       {
15687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15688       };
15689     } catch (...) {
15690       {
15691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15692       };
15693     }
15694   }
15695
15696   jresult = result;
15697
15698   //argout typemap for const std::string&
15699
15700   return jresult;
15701 }
15702
15703
15704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15705   unsigned int jresult ;
15706   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15707   Dali::Property::Index arg2 ;
15708   bool result;
15709
15710   arg1 = (Dali::Property::Key *)jarg1;
15711   arg2 = (Dali::Property::Index)jarg2;
15712   {
15713     try {
15714       result = (bool)(arg1)->operator !=(arg2);
15715     } catch (std::out_of_range& e) {
15716       {
15717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15718       };
15719     } catch (std::exception& e) {
15720       {
15721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15722       };
15723     } catch (Dali::DaliException e) {
15724       {
15725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15726       };
15727     } catch (...) {
15728       {
15729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15730       };
15731     }
15732   }
15733
15734   jresult = result;
15735   return jresult;
15736 }
15737
15738
15739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15740   unsigned int jresult ;
15741   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15742   Dali::Property::Key *arg2 = 0 ;
15743   bool result;
15744
15745   arg1 = (Dali::Property::Key *)jarg1;
15746   arg2 = (Dali::Property::Key *)jarg2;
15747   if (!arg2) {
15748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15749     return 0;
15750   }
15751   {
15752     try {
15753       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15754     } catch (std::out_of_range& e) {
15755       {
15756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15757       };
15758     } catch (std::exception& e) {
15759       {
15760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15761       };
15762     } catch (Dali::DaliException e) {
15763       {
15764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15765       };
15766     } catch (...) {
15767       {
15768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15769       };
15770     }
15771   }
15772
15773   jresult = result;
15774   return jresult;
15775 }
15776
15777
15778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15779   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15780
15781   arg1 = (Dali::Property::Key *)jarg1;
15782   {
15783     try {
15784       delete arg1;
15785     } catch (std::out_of_range& e) {
15786       {
15787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15788       };
15789     } catch (std::exception& e) {
15790       {
15791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15792       };
15793     } catch (Dali::DaliException e) {
15794       {
15795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15796       };
15797     } catch (...) {
15798       {
15799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15800       };
15801     }
15802   }
15803
15804 }
15805
15806
15807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15808   void * jresult ;
15809   Dali::Property::Map *result = 0 ;
15810
15811   {
15812     try {
15813       result = (Dali::Property::Map *)new Dali::Property::Map();
15814     } catch (std::out_of_range& e) {
15815       {
15816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15817       };
15818     } catch (std::exception& e) {
15819       {
15820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15821       };
15822     } catch (Dali::DaliException e) {
15823       {
15824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15825       };
15826     } catch (...) {
15827       {
15828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15829       };
15830     }
15831   }
15832
15833   jresult = (void *)result;
15834   return jresult;
15835 }
15836
15837
15838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15839   void * jresult ;
15840   Dali::Property::Map *arg1 = 0 ;
15841   Dali::Property::Map *result = 0 ;
15842
15843   arg1 = (Dali::Property::Map *)jarg1;
15844   if (!arg1) {
15845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15846     return 0;
15847   }
15848   {
15849     try {
15850       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15851     } catch (std::out_of_range& e) {
15852       {
15853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (std::exception& e) {
15856       {
15857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15858       };
15859     } catch (Dali::DaliException e) {
15860       {
15861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15862       };
15863     } catch (...) {
15864       {
15865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15866       };
15867     }
15868   }
15869
15870   jresult = (void *)result;
15871   return jresult;
15872 }
15873
15874
15875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15876   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15877
15878   arg1 = (Dali::Property::Map *)jarg1;
15879   {
15880     try {
15881       delete arg1;
15882     } catch (std::out_of_range& e) {
15883       {
15884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15885       };
15886     } catch (std::exception& e) {
15887       {
15888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15889       };
15890     } catch (Dali::DaliException e) {
15891       {
15892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15893       };
15894     } catch (...) {
15895       {
15896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15897       };
15898     }
15899   }
15900
15901 }
15902
15903
15904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15905   unsigned long jresult ;
15906   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15907   Dali::Property::Map::SizeType result;
15908
15909   arg1 = (Dali::Property::Map *)jarg1;
15910   {
15911     try {
15912       result = ((Dali::Property::Map const *)arg1)->Count();
15913     } catch (std::out_of_range& e) {
15914       {
15915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15916       };
15917     } catch (std::exception& e) {
15918       {
15919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15920       };
15921     } catch (Dali::DaliException e) {
15922       {
15923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15924       };
15925     } catch (...) {
15926       {
15927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15928       };
15929     }
15930   }
15931
15932   jresult = (unsigned long)result;
15933   return jresult;
15934 }
15935
15936
15937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15938   unsigned int jresult ;
15939   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15940   bool result;
15941
15942   arg1 = (Dali::Property::Map *)jarg1;
15943   {
15944     try {
15945       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15946     } catch (std::out_of_range& e) {
15947       {
15948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15949       };
15950     } catch (std::exception& e) {
15951       {
15952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15953       };
15954     } catch (Dali::DaliException e) {
15955       {
15956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15957       };
15958     } catch (...) {
15959       {
15960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15961       };
15962     }
15963   }
15964
15965   jresult = result;
15966   return jresult;
15967 }
15968
15969
15970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15971   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15972   char *arg2 = (char *) 0 ;
15973   Dali::Property::Value *arg3 = 0 ;
15974
15975   arg1 = (Dali::Property::Map *)jarg1;
15976   arg2 = (char *)jarg2;
15977   arg3 = (Dali::Property::Value *)jarg3;
15978   if (!arg3) {
15979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15980     return ;
15981   }
15982   {
15983     try {
15984       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15985     } catch (std::out_of_range& e) {
15986       {
15987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15988       };
15989     } catch (std::exception& e) {
15990       {
15991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15992       };
15993     } catch (Dali::DaliException e) {
15994       {
15995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15996       };
15997     } catch (...) {
15998       {
15999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16000       };
16001     }
16002   }
16003
16004 }
16005
16006
16007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16008   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16009   Dali::Property::Index arg2 ;
16010   Dali::Property::Value *arg3 = 0 ;
16011
16012   arg1 = (Dali::Property::Map *)jarg1;
16013   arg2 = (Dali::Property::Index)jarg2;
16014   arg3 = (Dali::Property::Value *)jarg3;
16015   if (!arg3) {
16016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16017     return ;
16018   }
16019   {
16020     try {
16021       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16022     } catch (std::out_of_range& e) {
16023       {
16024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16025       };
16026     } catch (std::exception& e) {
16027       {
16028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16029       };
16030     } catch (Dali::DaliException e) {
16031       {
16032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16033       };
16034     } catch (...) {
16035       {
16036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16037       };
16038     }
16039   }
16040
16041 }
16042
16043
16044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16045   void * jresult ;
16046   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16047   char *arg2 = (char *) 0 ;
16048   Dali::Property::Value *arg3 = 0 ;
16049   Dali::Property::Map *result = 0 ;
16050
16051   arg1 = (Dali::Property::Map *)jarg1;
16052   arg2 = (char *)jarg2;
16053   arg3 = (Dali::Property::Value *)jarg3;
16054   if (!arg3) {
16055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16056     return 0;
16057   }
16058   {
16059     try {
16060       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16061     } catch (std::out_of_range& e) {
16062       {
16063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16064       };
16065     } catch (std::exception& e) {
16066       {
16067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16068       };
16069     } catch (Dali::DaliException e) {
16070       {
16071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16072       };
16073     } catch (...) {
16074       {
16075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16076       };
16077     }
16078   }
16079
16080   jresult = (void *)result;
16081   return jresult;
16082 }
16083
16084
16085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16086   void * jresult ;
16087   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16088   Dali::Property::Index arg2 ;
16089   Dali::Property::Value *arg3 = 0 ;
16090   Dali::Property::Map *result = 0 ;
16091
16092   arg1 = (Dali::Property::Map *)jarg1;
16093   arg2 = (Dali::Property::Index)jarg2;
16094   arg3 = (Dali::Property::Value *)jarg3;
16095   if (!arg3) {
16096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16097     return 0;
16098   }
16099   {
16100     try {
16101       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16102     } catch (std::out_of_range& e) {
16103       {
16104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16105       };
16106     } catch (std::exception& e) {
16107       {
16108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16109       };
16110     } catch (Dali::DaliException e) {
16111       {
16112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16113       };
16114     } catch (...) {
16115       {
16116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16117       };
16118     }
16119   }
16120
16121   jresult = (void *)result;
16122   return jresult;
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16127   void * jresult ;
16128   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16129   Dali::Property::Map::SizeType arg2 ;
16130   Dali::Property::Value *result = 0 ;
16131
16132   arg1 = (Dali::Property::Map *)jarg1;
16133   arg2 = (Dali::Property::Map::SizeType)jarg2;
16134   {
16135     try {
16136       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16137     } catch (std::out_of_range& e) {
16138       {
16139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16140       };
16141     } catch (std::exception& e) {
16142       {
16143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (Dali::DaliException e) {
16146       {
16147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16148       };
16149     } catch (...) {
16150       {
16151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16152       };
16153     }
16154   }
16155
16156   jresult = (void *)result;
16157   return jresult;
16158 }
16159
16160
16161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16162   char * jresult ;
16163   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16164   Dali::Property::Map::SizeType arg2 ;
16165   std::string *result = 0 ;
16166
16167   arg1 = (Dali::Property::Map *)jarg1;
16168   arg2 = (Dali::Property::Map::SizeType)jarg2;
16169   {
16170     try {
16171       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16172     } catch (std::out_of_range& e) {
16173       {
16174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16175       };
16176     } catch (std::exception& e) {
16177       {
16178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (Dali::DaliException e) {
16181       {
16182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16183       };
16184     } catch (...) {
16185       {
16186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16187       };
16188     }
16189   }
16190
16191   jresult = SWIG_csharp_string_callback(result->c_str());
16192   return jresult;
16193 }
16194
16195
16196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16197   void * jresult ;
16198   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16199   Dali::Property::Map::SizeType arg2 ;
16200   SwigValueWrapper< Dali::Property::Key > result;
16201
16202   arg1 = (Dali::Property::Map *)jarg1;
16203   arg2 = (Dali::Property::Map::SizeType)jarg2;
16204   {
16205     try {
16206       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16207     } catch (std::out_of_range& e) {
16208       {
16209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16210       };
16211     } catch (std::exception& e) {
16212       {
16213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16214       };
16215     } catch (Dali::DaliException e) {
16216       {
16217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16218       };
16219     } catch (...) {
16220       {
16221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16222       };
16223     }
16224   }
16225
16226   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16227   return jresult;
16228 }
16229
16230
16231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16232   void * jresult ;
16233   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16234   Dali::Property::Map::SizeType arg2 ;
16235   StringValuePair *result = 0 ;
16236
16237   arg1 = (Dali::Property::Map *)jarg1;
16238   arg2 = (Dali::Property::Map::SizeType)jarg2;
16239   {
16240     try {
16241       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16242     } catch (std::out_of_range& e) {
16243       {
16244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16245       };
16246     } catch (std::exception& e) {
16247       {
16248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16249       };
16250     } catch (Dali::DaliException e) {
16251       {
16252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16253       };
16254     } catch (...) {
16255       {
16256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16257       };
16258     }
16259   }
16260
16261   jresult = (void *)result;
16262   return jresult;
16263 }
16264
16265
16266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16267   void * jresult ;
16268   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16269   char *arg2 = (char *) 0 ;
16270   Dali::Property::Value *result = 0 ;
16271
16272   arg1 = (Dali::Property::Map *)jarg1;
16273   arg2 = (char *)jarg2;
16274   {
16275     try {
16276       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16277     } catch (std::out_of_range& e) {
16278       {
16279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16280       };
16281     } catch (std::exception& e) {
16282       {
16283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16284       };
16285     } catch (Dali::DaliException e) {
16286       {
16287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16288       };
16289     } catch (...) {
16290       {
16291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16292       };
16293     }
16294   }
16295
16296   jresult = (void *)result;
16297   return jresult;
16298 }
16299
16300
16301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16302   void * jresult ;
16303   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16304   Dali::Property::Index arg2 ;
16305   Dali::Property::Value *result = 0 ;
16306
16307   arg1 = (Dali::Property::Map *)jarg1;
16308   arg2 = (Dali::Property::Index)jarg2;
16309   {
16310     try {
16311       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16312     } catch (std::out_of_range& e) {
16313       {
16314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16315       };
16316     } catch (std::exception& e) {
16317       {
16318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16319       };
16320     } catch (Dali::DaliException e) {
16321       {
16322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16323       };
16324     } catch (...) {
16325       {
16326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16327       };
16328     }
16329   }
16330
16331   jresult = (void *)result;
16332   return jresult;
16333 }
16334
16335
16336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16337   void * jresult ;
16338   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16339   Dali::Property::Index arg2 ;
16340   std::string *arg3 = 0 ;
16341   Dali::Property::Value *result = 0 ;
16342
16343   arg1 = (Dali::Property::Map *)jarg1;
16344   arg2 = (Dali::Property::Index)jarg2;
16345   if (!jarg3) {
16346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16347     return 0;
16348   }
16349   std::string arg3_str(jarg3);
16350   arg3 = &arg3_str;
16351   {
16352     try {
16353       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16354     } catch (std::out_of_range& e) {
16355       {
16356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16357       };
16358     } catch (std::exception& e) {
16359       {
16360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16361       };
16362     } catch (Dali::DaliException e) {
16363       {
16364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16365       };
16366     } catch (...) {
16367       {
16368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16369       };
16370     }
16371   }
16372
16373   jresult = (void *)result;
16374
16375   //argout typemap for const std::string&
16376
16377   return jresult;
16378 }
16379
16380
16381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16382   void * jresult ;
16383   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16384   std::string *arg2 = 0 ;
16385   Dali::Property::Type arg3 ;
16386   Dali::Property::Value *result = 0 ;
16387
16388   arg1 = (Dali::Property::Map *)jarg1;
16389   if (!jarg2) {
16390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16391     return 0;
16392   }
16393   std::string arg2_str(jarg2);
16394   arg2 = &arg2_str;
16395   arg3 = (Dali::Property::Type)jarg3;
16396   {
16397     try {
16398       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16399     } catch (std::out_of_range& e) {
16400       {
16401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16402       };
16403     } catch (std::exception& e) {
16404       {
16405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16406       };
16407     } catch (Dali::DaliException e) {
16408       {
16409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16410       };
16411     } catch (...) {
16412       {
16413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16414       };
16415     }
16416   }
16417
16418   jresult = (void *)result;
16419
16420   //argout typemap for const std::string&
16421
16422   return jresult;
16423 }
16424
16425
16426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16427   void * jresult ;
16428   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16429   Dali::Property::Index arg2 ;
16430   Dali::Property::Type arg3 ;
16431   Dali::Property::Value *result = 0 ;
16432
16433   arg1 = (Dali::Property::Map *)jarg1;
16434   arg2 = (Dali::Property::Index)jarg2;
16435   arg3 = (Dali::Property::Type)jarg3;
16436   {
16437     try {
16438       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16439     } catch (std::out_of_range& e) {
16440       {
16441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16442       };
16443     } catch (std::exception& e) {
16444       {
16445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16446       };
16447     } catch (Dali::DaliException e) {
16448       {
16449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16450       };
16451     } catch (...) {
16452       {
16453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16454       };
16455     }
16456   }
16457
16458   jresult = (void *)result;
16459   return jresult;
16460 }
16461
16462
16463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16464   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16465
16466   arg1 = (Dali::Property::Map *)jarg1;
16467   {
16468     try {
16469       (arg1)->Clear();
16470     } catch (std::out_of_range& e) {
16471       {
16472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16473       };
16474     } catch (std::exception& e) {
16475       {
16476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16477       };
16478     } catch (Dali::DaliException e) {
16479       {
16480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16481       };
16482     } catch (...) {
16483       {
16484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16485       };
16486     }
16487   }
16488
16489 }
16490
16491
16492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16493   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16494   Dali::Property::Map *arg2 = 0 ;
16495
16496   arg1 = (Dali::Property::Map *)jarg1;
16497   arg2 = (Dali::Property::Map *)jarg2;
16498   if (!arg2) {
16499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16500     return ;
16501   }
16502   {
16503     try {
16504       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16505     } catch (std::out_of_range& e) {
16506       {
16507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16508       };
16509     } catch (std::exception& e) {
16510       {
16511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16512       };
16513     } catch (Dali::DaliException e) {
16514       {
16515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16516       };
16517     } catch (...) {
16518       {
16519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16520       };
16521     }
16522   }
16523
16524 }
16525
16526
16527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16528   void * jresult ;
16529   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16530   std::string *arg2 = 0 ;
16531   Dali::Property::Value *result = 0 ;
16532
16533   arg1 = (Dali::Property::Map *)jarg1;
16534   if (!jarg2) {
16535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16536     return 0;
16537   }
16538   std::string arg2_str(jarg2);
16539   arg2 = &arg2_str;
16540   {
16541     try {
16542       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16543     } catch (std::out_of_range& e) {
16544       {
16545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16546       };
16547     } catch (std::exception& e) {
16548       {
16549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16550       };
16551     } catch (Dali::DaliException e) {
16552       {
16553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16554       };
16555     } catch (...) {
16556       {
16557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16558       };
16559     }
16560   }
16561
16562   jresult = (void *)result;
16563
16564   //argout typemap for const std::string&
16565
16566   return jresult;
16567 }
16568
16569
16570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16571   void * jresult ;
16572   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16573   Dali::Property::Index arg2 ;
16574   Dali::Property::Value *result = 0 ;
16575
16576   arg1 = (Dali::Property::Map *)jarg1;
16577   arg2 = (Dali::Property::Index)jarg2;
16578   {
16579     try {
16580       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16581     } catch (std::out_of_range& e) {
16582       {
16583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16584       };
16585     } catch (std::exception& e) {
16586       {
16587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16588       };
16589     } catch (Dali::DaliException e) {
16590       {
16591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16592       };
16593     } catch (...) {
16594       {
16595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16596       };
16597     }
16598   }
16599
16600   jresult = (void *)result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16606   void * jresult ;
16607   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16608   Dali::Property::Map *arg2 = 0 ;
16609   Dali::Property::Map *result = 0 ;
16610
16611   arg1 = (Dali::Property::Map *)jarg1;
16612   arg2 = (Dali::Property::Map *)jarg2;
16613   if (!arg2) {
16614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16615     return 0;
16616   }
16617   {
16618     try {
16619       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16620     } catch (std::out_of_range& e) {
16621       {
16622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16623       };
16624     } catch (std::exception& e) {
16625       {
16626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16627       };
16628     } catch (Dali::DaliException e) {
16629       {
16630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16631       };
16632     } catch (...) {
16633       {
16634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16635       };
16636     }
16637   }
16638
16639   jresult = (void *)result;
16640   return jresult;
16641 }
16642
16643
16644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16645   void * jresult ;
16646   Dali::Property::Value *result = 0 ;
16647
16648   {
16649     try {
16650       result = (Dali::Property::Value *)new Dali::Property::Value();
16651     } catch (std::out_of_range& e) {
16652       {
16653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16654       };
16655     } catch (std::exception& e) {
16656       {
16657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16658       };
16659     } catch (Dali::DaliException e) {
16660       {
16661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16662       };
16663     } catch (...) {
16664       {
16665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16666       };
16667     }
16668   }
16669
16670   jresult = (void *)result;
16671   return jresult;
16672 }
16673
16674
16675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16676   void * jresult ;
16677   bool arg1 ;
16678   Dali::Property::Value *result = 0 ;
16679
16680   arg1 = jarg1 ? true : false;
16681   {
16682     try {
16683       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16684     } catch (std::out_of_range& e) {
16685       {
16686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16687       };
16688     } catch (std::exception& e) {
16689       {
16690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16691       };
16692     } catch (Dali::DaliException e) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16695       };
16696     } catch (...) {
16697       {
16698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16699       };
16700     }
16701   }
16702
16703   jresult = (void *)result;
16704   return jresult;
16705 }
16706
16707
16708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16709   void * jresult ;
16710   int arg1 ;
16711   Dali::Property::Value *result = 0 ;
16712
16713   arg1 = (int)jarg1;
16714   {
16715     try {
16716       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16717     } catch (std::out_of_range& e) {
16718       {
16719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16720       };
16721     } catch (std::exception& e) {
16722       {
16723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16724       };
16725     } catch (Dali::DaliException e) {
16726       {
16727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16728       };
16729     } catch (...) {
16730       {
16731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16732       };
16733     }
16734   }
16735
16736   jresult = (void *)result;
16737   return jresult;
16738 }
16739
16740
16741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16742   void * jresult ;
16743   float arg1 ;
16744   Dali::Property::Value *result = 0 ;
16745
16746   arg1 = (float)jarg1;
16747   {
16748     try {
16749       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16750     } catch (std::out_of_range& e) {
16751       {
16752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16753       };
16754     } catch (std::exception& e) {
16755       {
16756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16757       };
16758     } catch (Dali::DaliException e) {
16759       {
16760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16761       };
16762     } catch (...) {
16763       {
16764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16765       };
16766     }
16767   }
16768
16769   jresult = (void *)result;
16770   return jresult;
16771 }
16772
16773
16774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16775   void * jresult ;
16776   Dali::Vector2 *arg1 = 0 ;
16777   Dali::Property::Value *result = 0 ;
16778
16779   arg1 = (Dali::Vector2 *)jarg1;
16780   if (!arg1) {
16781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16782     return 0;
16783   }
16784   {
16785     try {
16786       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16794       };
16795     } catch (Dali::DaliException e) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16798       };
16799     } catch (...) {
16800       {
16801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16802       };
16803     }
16804   }
16805
16806   jresult = (void *)result;
16807   return jresult;
16808 }
16809
16810
16811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16812   void * jresult ;
16813   Dali::Vector3 *arg1 = 0 ;
16814   Dali::Property::Value *result = 0 ;
16815
16816   arg1 = (Dali::Vector3 *)jarg1;
16817   if (!arg1) {
16818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16819     return 0;
16820   }
16821   {
16822     try {
16823       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16824     } catch (std::out_of_range& e) {
16825       {
16826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16827       };
16828     } catch (std::exception& e) {
16829       {
16830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16831       };
16832     } catch (Dali::DaliException e) {
16833       {
16834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16835       };
16836     } catch (...) {
16837       {
16838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16839       };
16840     }
16841   }
16842
16843   jresult = (void *)result;
16844   return jresult;
16845 }
16846
16847
16848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16849   void * jresult ;
16850   Dali::Vector4 *arg1 = 0 ;
16851   Dali::Property::Value *result = 0 ;
16852
16853   arg1 = (Dali::Vector4 *)jarg1;
16854   if (!arg1) {
16855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16856     return 0;
16857   }
16858   {
16859     try {
16860       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16861     } catch (std::out_of_range& e) {
16862       {
16863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (std::exception& e) {
16866       {
16867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16868       };
16869     } catch (Dali::DaliException e) {
16870       {
16871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16876       };
16877     }
16878   }
16879
16880   jresult = (void *)result;
16881   return jresult;
16882 }
16883
16884
16885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16886   void * jresult ;
16887   Dali::Matrix3 *arg1 = 0 ;
16888   Dali::Property::Value *result = 0 ;
16889
16890   arg1 = (Dali::Matrix3 *)jarg1;
16891   if (!arg1) {
16892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16893     return 0;
16894   }
16895   {
16896     try {
16897       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16898     } catch (std::out_of_range& e) {
16899       {
16900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (std::exception& e) {
16903       {
16904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16905       };
16906     } catch (Dali::DaliException e) {
16907       {
16908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16909       };
16910     } catch (...) {
16911       {
16912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16913       };
16914     }
16915   }
16916
16917   jresult = (void *)result;
16918   return jresult;
16919 }
16920
16921
16922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16923   void * jresult ;
16924   Dali::Matrix *arg1 = 0 ;
16925   Dali::Property::Value *result = 0 ;
16926
16927   arg1 = (Dali::Matrix *)jarg1;
16928   if (!arg1) {
16929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16930     return 0;
16931   }
16932   {
16933     try {
16934       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16935     } catch (std::out_of_range& e) {
16936       {
16937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16938       };
16939     } catch (std::exception& e) {
16940       {
16941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (Dali::DaliException e) {
16944       {
16945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953
16954   jresult = (void *)result;
16955   return jresult;
16956 }
16957
16958
16959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16960   void * jresult ;
16961   Dali::Rect< int > *arg1 = 0 ;
16962   Dali::Property::Value *result = 0 ;
16963
16964   arg1 = (Dali::Rect< int > *)jarg1;
16965   if (!arg1) {
16966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16967     return 0;
16968   }
16969   {
16970     try {
16971       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16972     } catch (std::out_of_range& e) {
16973       {
16974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16975       };
16976     } catch (std::exception& e) {
16977       {
16978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16979       };
16980     } catch (Dali::DaliException e) {
16981       {
16982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16983       };
16984     } catch (...) {
16985       {
16986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16987       };
16988     }
16989   }
16990
16991   jresult = (void *)result;
16992   return jresult;
16993 }
16994
16995
16996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16997   void * jresult ;
16998   Dali::AngleAxis *arg1 = 0 ;
16999   Dali::Property::Value *result = 0 ;
17000
17001   arg1 = (Dali::AngleAxis *)jarg1;
17002   if (!arg1) {
17003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17004     return 0;
17005   }
17006   {
17007     try {
17008       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17009     } catch (std::out_of_range& e) {
17010       {
17011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17012       };
17013     } catch (std::exception& e) {
17014       {
17015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17016       };
17017     } catch (Dali::DaliException e) {
17018       {
17019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17020       };
17021     } catch (...) {
17022       {
17023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17024       };
17025     }
17026   }
17027
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17034   void * jresult ;
17035   Dali::Quaternion *arg1 = 0 ;
17036   Dali::Property::Value *result = 0 ;
17037
17038   arg1 = (Dali::Quaternion *)jarg1;
17039   if (!arg1) {
17040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17041     return 0;
17042   }
17043   {
17044     try {
17045       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17046     } catch (std::out_of_range& e) {
17047       {
17048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17049       };
17050     } catch (std::exception& e) {
17051       {
17052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17053       };
17054     } catch (Dali::DaliException e) {
17055       {
17056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17057       };
17058     } catch (...) {
17059       {
17060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17061       };
17062     }
17063   }
17064
17065   jresult = (void *)result;
17066   return jresult;
17067 }
17068
17069
17070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17071   void * jresult ;
17072   std::string *arg1 = 0 ;
17073   Dali::Property::Value *result = 0 ;
17074
17075   if (!jarg1) {
17076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17077     return 0;
17078   }
17079   std::string arg1_str(jarg1);
17080   arg1 = &arg1_str;
17081   {
17082     try {
17083       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17084     } catch (std::out_of_range& e) {
17085       {
17086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17087       };
17088     } catch (std::exception& e) {
17089       {
17090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17091       };
17092     } catch (Dali::DaliException e) {
17093       {
17094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17095       };
17096     } catch (...) {
17097       {
17098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17099       };
17100     }
17101   }
17102
17103   jresult = (void *)result;
17104
17105   //argout typemap for const std::string&
17106
17107   return jresult;
17108 }
17109
17110
17111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17112   void * jresult ;
17113   Dali::Property::Array *arg1 = 0 ;
17114   Dali::Property::Value *result = 0 ;
17115
17116   arg1 = (Dali::Property::Array *)jarg1;
17117   if (!arg1) {
17118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17119     return 0;
17120   }
17121   {
17122     try {
17123       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17124     } catch (std::out_of_range& e) {
17125       {
17126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17127       };
17128     } catch (std::exception& e) {
17129       {
17130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17131       };
17132     } catch (Dali::DaliException e) {
17133       {
17134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17135       };
17136     } catch (...) {
17137       {
17138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17139       };
17140     }
17141   }
17142
17143   jresult = (void *)result;
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17149   void * jresult ;
17150   Dali::Property::Map *arg1 = 0 ;
17151   Dali::Property::Value *result = 0 ;
17152
17153   arg1 = (Dali::Property::Map *)jarg1;
17154   if (!arg1) {
17155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17156     return 0;
17157   }
17158   {
17159     try {
17160       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17161     } catch (std::out_of_range& e) {
17162       {
17163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (std::exception& e) {
17166       {
17167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17168       };
17169     } catch (Dali::DaliException e) {
17170       {
17171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17172       };
17173     } catch (...) {
17174       {
17175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17176       };
17177     }
17178   }
17179
17180   jresult = (void *)result;
17181   return jresult;
17182 }
17183
17184
17185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17186   void * jresult ;
17187   Extents *arg1 = 0 ;
17188   Dali::Property::Value *result = 0 ;
17189
17190   arg1 = (Extents *)jarg1;
17191   if (!arg1) {
17192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17193     return 0;
17194   }
17195   {
17196     try {
17197       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17198     } catch (std::out_of_range& e) {
17199       {
17200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17201       };
17202     } catch (std::exception& e) {
17203       {
17204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17205       };
17206     } catch (...) {
17207       {
17208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17209       };
17210     }
17211   }
17212   jresult = (void *)result;
17213   return jresult;
17214 }
17215
17216
17217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17218   void * jresult ;
17219   Dali::Property::Type arg1 ;
17220   Dali::Property::Value *result = 0 ;
17221
17222   arg1 = (Dali::Property::Type)jarg1;
17223   {
17224     try {
17225       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17226     } catch (std::out_of_range& e) {
17227       {
17228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17229       };
17230     } catch (std::exception& e) {
17231       {
17232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17233       };
17234     } catch (Dali::DaliException e) {
17235       {
17236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17237       };
17238     } catch (...) {
17239       {
17240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17241       };
17242     }
17243   }
17244
17245   jresult = (void *)result;
17246   return jresult;
17247 }
17248
17249
17250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17251   void * jresult ;
17252   Dali::Property::Value *arg1 = 0 ;
17253   Dali::Property::Value *result = 0 ;
17254
17255   arg1 = (Dali::Property::Value *)jarg1;
17256   if (!arg1) {
17257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17258     return 0;
17259   }
17260   {
17261     try {
17262       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17263     } catch (std::out_of_range& e) {
17264       {
17265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17266       };
17267     } catch (std::exception& e) {
17268       {
17269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17270       };
17271     } catch (Dali::DaliException e) {
17272       {
17273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17274       };
17275     } catch (...) {
17276       {
17277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17278       };
17279     }
17280   }
17281
17282   jresult = (void *)result;
17283   return jresult;
17284 }
17285
17286
17287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17288   void * jresult ;
17289   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17290   Dali::Property::Value *arg2 = 0 ;
17291   Dali::Property::Value *result = 0 ;
17292
17293   arg1 = (Dali::Property::Value *)jarg1;
17294   arg2 = (Dali::Property::Value *)jarg2;
17295   if (!arg2) {
17296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17297     return 0;
17298   }
17299   {
17300     try {
17301       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17302     } catch (std::out_of_range& e) {
17303       {
17304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17305       };
17306     } catch (std::exception& e) {
17307       {
17308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17309       };
17310     } catch (Dali::DaliException e) {
17311       {
17312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17313       };
17314     } catch (...) {
17315       {
17316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17317       };
17318     }
17319   }
17320
17321   jresult = (void *)result;
17322   return jresult;
17323 }
17324
17325
17326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17327   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17328
17329   arg1 = (Dali::Property::Value *)jarg1;
17330   {
17331     try {
17332       delete arg1;
17333     } catch (std::out_of_range& e) {
17334       {
17335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17336       };
17337     } catch (std::exception& e) {
17338       {
17339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17340       };
17341     } catch (Dali::DaliException e) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17344       };
17345     } catch (...) {
17346       {
17347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17348       };
17349     }
17350   }
17351
17352 }
17353
17354
17355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17356   int jresult ;
17357   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17358   Dali::Property::Type result;
17359
17360   arg1 = (Dali::Property::Value *)jarg1;
17361   {
17362     try {
17363       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (Dali::DaliException e) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17375       };
17376     } catch (...) {
17377       {
17378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17379       };
17380     }
17381   }
17382
17383   jresult = (int)result;
17384   return jresult;
17385 }
17386
17387
17388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17389   unsigned int jresult ;
17390   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17391   bool *arg2 = 0 ;
17392   bool result;
17393
17394   arg1 = (Dali::Property::Value *)jarg1;
17395   arg2 = (bool *)jarg2;
17396   {
17397     try {
17398       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17399     } catch (std::out_of_range& e) {
17400       {
17401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17402       };
17403     } catch (std::exception& e) {
17404       {
17405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17406       };
17407     } catch (Dali::DaliException e) {
17408       {
17409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17410       };
17411     } catch (...) {
17412       {
17413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17414       };
17415     }
17416   }
17417
17418   jresult = result;
17419   return jresult;
17420 }
17421
17422
17423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17424   unsigned int jresult ;
17425   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17426   float *arg2 = 0 ;
17427   bool result;
17428
17429   arg1 = (Dali::Property::Value *)jarg1;
17430   arg2 = (float *)jarg2;
17431   {
17432     try {
17433       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17434     } catch (std::out_of_range& e) {
17435       {
17436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17437       };
17438     } catch (std::exception& e) {
17439       {
17440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17441       };
17442     } catch (Dali::DaliException e) {
17443       {
17444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17445       };
17446     } catch (...) {
17447       {
17448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17449       };
17450     }
17451   }
17452
17453   jresult = result;
17454   return jresult;
17455 }
17456
17457
17458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17459   unsigned int jresult ;
17460   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17461   int *arg2 = 0 ;
17462   bool result;
17463
17464   arg1 = (Dali::Property::Value *)jarg1;
17465   arg2 = (int *)jarg2;
17466   {
17467     try {
17468       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17469     } catch (std::out_of_range& e) {
17470       {
17471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17472       };
17473     } catch (std::exception& e) {
17474       {
17475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (Dali::DaliException e) {
17478       {
17479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17480       };
17481     } catch (...) {
17482       {
17483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17484       };
17485     }
17486   }
17487
17488   jresult = result;
17489   return jresult;
17490 }
17491
17492
17493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17494   unsigned int jresult ;
17495   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17496   Dali::Rect< int > *arg2 = 0 ;
17497   bool result;
17498
17499   arg1 = (Dali::Property::Value *)jarg1;
17500   arg2 = (Dali::Rect< int > *)jarg2;
17501   if (!arg2) {
17502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17503     return 0;
17504   }
17505   {
17506     try {
17507       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17508     } catch (std::out_of_range& e) {
17509       {
17510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17511       };
17512     } catch (std::exception& e) {
17513       {
17514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17515       };
17516     } catch (Dali::DaliException e) {
17517       {
17518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17519       };
17520     } catch (...) {
17521       {
17522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17523       };
17524     }
17525   }
17526
17527   jresult = result;
17528   return jresult;
17529 }
17530
17531
17532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17533   unsigned int jresult ;
17534   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17535   Dali::Vector2 *arg2 = 0 ;
17536   bool result;
17537
17538   arg1 = (Dali::Property::Value *)jarg1;
17539   arg2 = (Dali::Vector2 *)jarg2;
17540   if (!arg2) {
17541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17542     return 0;
17543   }
17544   {
17545     try {
17546       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17547     } catch (std::out_of_range& e) {
17548       {
17549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17550       };
17551     } catch (std::exception& e) {
17552       {
17553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17554       };
17555     } catch (Dali::DaliException e) {
17556       {
17557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17558       };
17559     } catch (...) {
17560       {
17561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17562       };
17563     }
17564   }
17565
17566   jresult = result;
17567   return jresult;
17568 }
17569
17570
17571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17572   unsigned int jresult ;
17573   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17574   Dali::Vector3 *arg2 = 0 ;
17575   bool result;
17576
17577   arg1 = (Dali::Property::Value *)jarg1;
17578   arg2 = (Dali::Vector3 *)jarg2;
17579   if (!arg2) {
17580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17581     return 0;
17582   }
17583   {
17584     try {
17585       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17586     } catch (std::out_of_range& e) {
17587       {
17588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17589       };
17590     } catch (std::exception& e) {
17591       {
17592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17593       };
17594     } catch (Dali::DaliException e) {
17595       {
17596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17597       };
17598     } catch (...) {
17599       {
17600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17601       };
17602     }
17603   }
17604
17605   jresult = result;
17606   return jresult;
17607 }
17608
17609
17610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17611   unsigned int jresult ;
17612   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17613   Dali::Vector4 *arg2 = 0 ;
17614   bool result;
17615
17616   arg1 = (Dali::Property::Value *)jarg1;
17617   arg2 = (Dali::Vector4 *)jarg2;
17618   if (!arg2) {
17619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17620     return 0;
17621   }
17622   {
17623     try {
17624       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17625     } catch (std::out_of_range& e) {
17626       {
17627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17628       };
17629     } catch (std::exception& e) {
17630       {
17631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (Dali::DaliException e) {
17634       {
17635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17636       };
17637     } catch (...) {
17638       {
17639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17640       };
17641     }
17642   }
17643
17644   jresult = result;
17645   return jresult;
17646 }
17647
17648
17649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17650   unsigned int jresult ;
17651   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17652   Dali::Matrix3 *arg2 = 0 ;
17653   bool result;
17654
17655   arg1 = (Dali::Property::Value *)jarg1;
17656   arg2 = (Dali::Matrix3 *)jarg2;
17657   if (!arg2) {
17658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17659     return 0;
17660   }
17661   {
17662     try {
17663       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17664     } catch (std::out_of_range& e) {
17665       {
17666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17667       };
17668     } catch (std::exception& e) {
17669       {
17670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17671       };
17672     } catch (Dali::DaliException e) {
17673       {
17674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17675       };
17676     } catch (...) {
17677       {
17678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17679       };
17680     }
17681   }
17682
17683   jresult = result;
17684   return jresult;
17685 }
17686
17687
17688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17689   unsigned int jresult ;
17690   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17691   Dali::Matrix *arg2 = 0 ;
17692   bool result;
17693
17694   arg1 = (Dali::Property::Value *)jarg1;
17695   arg2 = (Dali::Matrix *)jarg2;
17696   if (!arg2) {
17697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17698     return 0;
17699   }
17700   {
17701     try {
17702       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17703     } catch (std::out_of_range& e) {
17704       {
17705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17706       };
17707     } catch (std::exception& e) {
17708       {
17709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17710       };
17711     } catch (Dali::DaliException e) {
17712       {
17713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17714       };
17715     } catch (...) {
17716       {
17717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17718       };
17719     }
17720   }
17721
17722   jresult = result;
17723   return jresult;
17724 }
17725
17726
17727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17728   unsigned int jresult ;
17729   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17730   Dali::AngleAxis *arg2 = 0 ;
17731   bool result;
17732
17733   arg1 = (Dali::Property::Value *)jarg1;
17734   arg2 = (Dali::AngleAxis *)jarg2;
17735   if (!arg2) {
17736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17737     return 0;
17738   }
17739   {
17740     try {
17741       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17742     } catch (std::out_of_range& e) {
17743       {
17744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17745       };
17746     } catch (std::exception& e) {
17747       {
17748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17749       };
17750     } catch (Dali::DaliException e) {
17751       {
17752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17753       };
17754     } catch (...) {
17755       {
17756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17757       };
17758     }
17759   }
17760
17761   jresult = result;
17762   return jresult;
17763 }
17764
17765
17766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17767   unsigned int jresult ;
17768   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17769   Dali::Quaternion *arg2 = 0 ;
17770   bool result;
17771
17772   arg1 = (Dali::Property::Value *)jarg1;
17773   arg2 = (Dali::Quaternion *)jarg2;
17774   if (!arg2) {
17775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17776     return 0;
17777   }
17778   {
17779     try {
17780       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17781     } catch (std::out_of_range& e) {
17782       {
17783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17784       };
17785     } catch (std::exception& e) {
17786       {
17787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17788       };
17789     } catch (Dali::DaliException e) {
17790       {
17791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17792       };
17793     } catch (...) {
17794       {
17795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17796       };
17797     }
17798   }
17799
17800   jresult = result;
17801   return jresult;
17802 }
17803
17804
17805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17806   unsigned int jresult ;
17807   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17808   std::string *arg2 = 0 ;
17809   bool result;
17810
17811   arg1 = (Dali::Property::Value *)jarg1;
17812
17813   //typemap in
17814   std::string temp;
17815   arg2 = &temp;
17816
17817   {
17818     try {
17819       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17820     } catch (std::out_of_range& e) {
17821       {
17822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (std::exception& e) {
17825       {
17826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17827       };
17828     } catch (Dali::DaliException e) {
17829       {
17830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17831       };
17832     } catch (...) {
17833       {
17834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17835       };
17836     }
17837   }
17838
17839   jresult = result;
17840
17841   //Typemap argout in c++ file.
17842   //This will convert c++ string to c# string
17843   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17844
17845   return jresult;
17846 }
17847
17848
17849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17850   unsigned int jresult ;
17851   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17852   Dali::Property::Array *arg2 = 0 ;
17853   bool result;
17854
17855   arg1 = (Dali::Property::Value *)jarg1;
17856   arg2 = (Dali::Property::Array *)jarg2;
17857   if (!arg2) {
17858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17859     return 0;
17860   }
17861   {
17862     try {
17863       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17864     } catch (std::out_of_range& e) {
17865       {
17866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17867       };
17868     } catch (std::exception& e) {
17869       {
17870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17871       };
17872     } catch (Dali::DaliException e) {
17873       {
17874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17875       };
17876     } catch (...) {
17877       {
17878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17879       };
17880     }
17881   }
17882
17883   jresult = result;
17884   return jresult;
17885 }
17886
17887
17888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17889   unsigned int jresult ;
17890   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17891   Dali::Property::Map *arg2 = 0 ;
17892   bool result;
17893
17894   arg1 = (Dali::Property::Value *)jarg1;
17895   arg2 = (Dali::Property::Map *)jarg2;
17896   if (!arg2) {
17897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17898     return 0;
17899   }
17900   {
17901     try {
17902       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17903     } catch (std::out_of_range& e) {
17904       {
17905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17906       };
17907     } catch (std::exception& e) {
17908       {
17909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17910       };
17911     } catch (Dali::DaliException e) {
17912       {
17913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17914       };
17915     } catch (...) {
17916       {
17917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17918       };
17919     }
17920   }
17921
17922   jresult = result;
17923   return jresult;
17924 }
17925
17926
17927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17928   unsigned int jresult ;
17929   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17930   Extents *arg2 = 0 ;
17931   bool result;
17932
17933   arg1 = (Dali::Property::Value *)jarg1;
17934   arg2 = (Extents *)jarg2;
17935   if (!arg2) {
17936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17937     return 0;
17938   }
17939   {
17940     try {
17941       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17942     } catch (std::out_of_range& e) {
17943       {
17944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (std::exception& e) {
17947       {
17948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17949       };
17950     } catch (...) {
17951       {
17952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17953       };
17954     }
17955   }
17956   jresult = result;
17957   return jresult;
17958 }
17959
17960
17961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17962   void * jresult ;
17963   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17964   Dali::Property::Array *result = 0 ;
17965
17966   arg1 = (Dali::Property::Value *)jarg1;
17967   {
17968     try {
17969       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17970     } catch (std::out_of_range& e) {
17971       {
17972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17973       };
17974     } catch (std::exception& e) {
17975       {
17976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17977       };
17978     } catch (Dali::DaliException e) {
17979       {
17980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17981       };
17982     } catch (...) {
17983       {
17984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17985       };
17986     }
17987   }
17988
17989   jresult = (void *)result;
17990   return jresult;
17991 }
17992
17993
17994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17995   void * jresult ;
17996   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17997   Dali::Property::Map *result = 0 ;
17998
17999   arg1 = (Dali::Property::Value *)jarg1;
18000   {
18001     try {
18002       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18003     } catch (std::out_of_range& e) {
18004       {
18005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18006       };
18007     } catch (std::exception& e) {
18008       {
18009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (Dali::DaliException e) {
18012       {
18013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18014       };
18015     } catch (...) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18018       };
18019     }
18020   }
18021
18022   jresult = (void *)result;
18023   return jresult;
18024 }
18025
18026
18027 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18028   char * jresult ;
18029   Dali::Property::Type arg1 ;
18030   char *result = 0 ;
18031
18032   arg1 = (Dali::Property::Type)jarg1;
18033   {
18034     try {
18035       result = (char *)Dali::PropertyTypes::GetName(arg1);
18036     } catch (std::out_of_range& e) {
18037       {
18038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18039       };
18040     } catch (std::exception& e) {
18041       {
18042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (Dali::DaliException e) {
18045       {
18046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18047       };
18048     } catch (...) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18051       };
18052     }
18053   }
18054
18055   jresult = SWIG_csharp_string_callback((const char *)result);
18056   return jresult;
18057 }
18058
18059
18060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18061   unsigned int jresult ;
18062   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18063   std::string *arg2 = 0 ;
18064   Dali::Property::Map *arg3 = 0 ;
18065   bool result;
18066
18067   arg1 = (Dali::BaseObject *)jarg1;
18068   if (!jarg2) {
18069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18070     return 0;
18071   }
18072   std::string arg2_str(jarg2);
18073   arg2 = &arg2_str;
18074   arg3 = (Dali::Property::Map *)jarg3;
18075   if (!arg3) {
18076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18077     return 0;
18078   }
18079   {
18080     try {
18081       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18082     } catch (std::out_of_range& e) {
18083       {
18084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (std::exception& e) {
18087       {
18088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18089       };
18090     } catch (Dali::DaliException e) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18093       };
18094     } catch (...) {
18095       {
18096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18097       };
18098     }
18099   }
18100
18101   jresult = result;
18102
18103   //argout typemap for const std::string&
18104
18105   return jresult;
18106 }
18107
18108
18109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18110   char * jresult ;
18111   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18112   std::string *result = 0 ;
18113
18114   arg1 = (Dali::BaseObject *)jarg1;
18115   {
18116     try {
18117       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18118     } catch (std::out_of_range& e) {
18119       {
18120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18121       };
18122     } catch (std::exception& e) {
18123       {
18124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18125       };
18126     } catch (Dali::DaliException e) {
18127       {
18128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18129       };
18130     } catch (...) {
18131       {
18132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18133       };
18134     }
18135   }
18136
18137   jresult = SWIG_csharp_string_callback(result->c_str());
18138   return jresult;
18139 }
18140
18141
18142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18143   unsigned int jresult ;
18144   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18145   Dali::TypeInfo *arg2 = 0 ;
18146   bool result;
18147
18148   arg1 = (Dali::BaseObject *)jarg1;
18149   arg2 = (Dali::TypeInfo *)jarg2;
18150   if (!arg2) {
18151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18152     return 0;
18153   }
18154   {
18155     try {
18156       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18157     } catch (std::out_of_range& e) {
18158       {
18159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (std::exception& e) {
18162       {
18163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18164       };
18165     } catch (Dali::DaliException e) {
18166       {
18167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18168       };
18169     } catch (...) {
18170       {
18171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18172       };
18173     }
18174   }
18175
18176   jresult = result;
18177   return jresult;
18178 }
18179
18180
18181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18182   unsigned int jresult ;
18183   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18184   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18185   std::string *arg3 = 0 ;
18186   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18187   bool result;
18188
18189   arg1 = (Dali::BaseObject *)jarg1;
18190   arg2 = (ConnectionTrackerInterface *)jarg2;
18191   if (!jarg3) {
18192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18193     return 0;
18194   }
18195   std::string arg3_str(jarg3);
18196   arg3 = &arg3_str;
18197   arg4 = (FunctorDelegate *)jarg4;
18198   {
18199     try {
18200       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18201     } catch (std::out_of_range& e) {
18202       {
18203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18204       };
18205     } catch (std::exception& e) {
18206       {
18207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18208       };
18209     } catch (Dali::DaliException e) {
18210       {
18211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18212       };
18213     } catch (...) {
18214       {
18215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18216       };
18217     }
18218   }
18219
18220   jresult = result;
18221
18222   //argout typemap for const std::string&
18223
18224   return jresult;
18225 }
18226
18227
18228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18229   void * jresult ;
18230   Dali::BaseHandle *arg1 = 0 ;
18231   Dali::BaseObject *result = 0 ;
18232
18233   arg1 = (Dali::BaseHandle *)jarg1;
18234   if (!arg1) {
18235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18236     return 0;
18237   }
18238   {
18239     try {
18240       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18241     } catch (std::out_of_range& e) {
18242       {
18243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18244       };
18245     } catch (std::exception& e) {
18246       {
18247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18248       };
18249     } catch (Dali::DaliException e) {
18250       {
18251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18252       };
18253     } catch (...) {
18254       {
18255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18256       };
18257     }
18258   }
18259
18260   jresult = (void *)result;
18261   return jresult;
18262 }
18263
18264
18265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18266   void * jresult ;
18267   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18268   Dali::BaseHandle *result = 0 ;
18269
18270   arg1 = (Dali::BaseObject *)jarg1;
18271   {
18272     try {
18273       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18274     } catch (std::out_of_range& e) {
18275       {
18276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18277       };
18278     } catch (std::exception& e) {
18279       {
18280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18281       };
18282     } catch (Dali::DaliException e) {
18283       {
18284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18285       };
18286     } catch (...) {
18287       {
18288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18289       };
18290     }
18291   }
18292
18293   jresult = (void *)result;
18294   return jresult;
18295 }
18296
18297
18298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18299   void * jresult ;
18300   Dali::BaseHandle *result = 0 ;
18301
18302   {
18303     try {
18304       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18305     } catch (std::out_of_range& e) {
18306       {
18307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18308       };
18309     } catch (std::exception& e) {
18310       {
18311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18312       };
18313     } catch (Dali::DaliException e) {
18314       {
18315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18316       };
18317     } catch (...) {
18318       {
18319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18320       };
18321     }
18322   }
18323
18324   jresult = (void *)result;
18325   return jresult;
18326 }
18327
18328
18329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18330   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18331
18332   arg1 = (Dali::BaseHandle *)jarg1;
18333   {
18334     try {
18335       delete arg1;
18336     } catch (std::out_of_range& e) {
18337       {
18338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18339       };
18340     } catch (std::exception& e) {
18341       {
18342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18343       };
18344     } catch (Dali::DaliException e) {
18345       {
18346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18347       };
18348     } catch (...) {
18349       {
18350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18351       };
18352     }
18353   }
18354
18355 }
18356
18357
18358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18359   void * jresult ;
18360   Dali::BaseHandle *arg1 = 0 ;
18361   Dali::BaseHandle *result = 0 ;
18362
18363   arg1 = (Dali::BaseHandle *)jarg1;
18364   if (!arg1) {
18365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18366     return 0;
18367   }
18368   {
18369     try {
18370       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18371     } catch (std::out_of_range& e) {
18372       {
18373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18374       };
18375     } catch (std::exception& e) {
18376       {
18377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18378       };
18379     } catch (Dali::DaliException e) {
18380       {
18381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18382       };
18383     } catch (...) {
18384       {
18385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18386       };
18387     }
18388   }
18389
18390   jresult = (void *)result;
18391   return jresult;
18392 }
18393
18394
18395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18396   void * jresult ;
18397   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18398   Dali::BaseHandle *arg2 = 0 ;
18399   Dali::BaseHandle *result = 0 ;
18400
18401   arg1 = (Dali::BaseHandle *)jarg1;
18402   arg2 = (Dali::BaseHandle *)jarg2;
18403   if (!arg2) {
18404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18405     return 0;
18406   }
18407   {
18408     try {
18409       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18410     } catch (std::out_of_range& e) {
18411       {
18412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18413       };
18414     } catch (std::exception& e) {
18415       {
18416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18417       };
18418     } catch (Dali::DaliException e) {
18419       {
18420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18421       };
18422     } catch (...) {
18423       {
18424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18425       };
18426     }
18427   }
18428
18429   jresult = (void *)result;
18430   return jresult;
18431 }
18432
18433
18434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18435   unsigned int jresult ;
18436   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18437   std::string *arg2 = 0 ;
18438   Dali::Property::Map *arg3 = 0 ;
18439   bool result;
18440
18441   arg1 = (Dali::BaseHandle *)jarg1;
18442   if (!jarg2) {
18443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18444     return 0;
18445   }
18446   std::string arg2_str(jarg2);
18447   arg2 = &arg2_str;
18448   arg3 = (Dali::Property::Map *)jarg3;
18449   if (!arg3) {
18450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18451     return 0;
18452   }
18453   {
18454     try {
18455       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18456     } catch (std::out_of_range& e) {
18457       {
18458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18459       };
18460     } catch (std::exception& e) {
18461       {
18462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18463       };
18464     } catch (Dali::DaliException e) {
18465       {
18466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18467       };
18468     } catch (...) {
18469       {
18470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18471       };
18472     }
18473   }
18474
18475   jresult = result;
18476
18477   //argout typemap for const std::string&
18478
18479   return jresult;
18480 }
18481
18482
18483 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18484   char * jresult ;
18485   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18486   std::string *result = 0 ;
18487
18488   arg1 = (Dali::BaseHandle *)jarg1;
18489   {
18490     try {
18491       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18492     } catch (std::out_of_range& e) {
18493       {
18494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18495       };
18496     } catch (std::exception& e) {
18497       {
18498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18499       };
18500     } catch (Dali::DaliException e) {
18501       {
18502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18503       };
18504     } catch (...) {
18505       {
18506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18507       };
18508     }
18509   }
18510
18511   jresult = SWIG_csharp_string_callback(result->c_str());
18512   return jresult;
18513 }
18514
18515
18516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18517   unsigned int jresult ;
18518   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18519   Dali::TypeInfo *arg2 = 0 ;
18520   bool result;
18521
18522   arg1 = (Dali::BaseHandle *)jarg1;
18523   arg2 = (Dali::TypeInfo *)jarg2;
18524   if (!arg2) {
18525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18526     return 0;
18527   }
18528   {
18529     try {
18530       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (Dali::DaliException e) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549
18550   jresult = result;
18551   return jresult;
18552 }
18553
18554
18555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18556   void * jresult ;
18557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18558   Dali::BaseObject *result = 0 ;
18559
18560   arg1 = (Dali::BaseHandle *)jarg1;
18561   {
18562     try {
18563       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18564     } catch (std::out_of_range& e) {
18565       {
18566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18567       };
18568     } catch (std::exception& e) {
18569       {
18570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18571       };
18572     } catch (Dali::DaliException e) {
18573       {
18574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18575       };
18576     } catch (...) {
18577       {
18578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18579       };
18580     }
18581   }
18582
18583   jresult = (void *)result;
18584   return jresult;
18585 }
18586
18587
18588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18589   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18590
18591   arg1 = (Dali::BaseHandle *)jarg1;
18592   {
18593     try {
18594       (arg1)->Reset();
18595     } catch (std::out_of_range& e) {
18596       {
18597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18598       };
18599     } catch (std::exception& e) {
18600       {
18601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18602       };
18603     } catch (Dali::DaliException e) {
18604       {
18605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18606       };
18607     } catch (...) {
18608       {
18609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18610       };
18611     }
18612   }
18613
18614 }
18615
18616
18617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18618   unsigned int jresult ;
18619   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18620   Dali::BaseHandle *arg2 = 0 ;
18621   bool result;
18622
18623   arg1 = (Dali::BaseHandle *)jarg1;
18624   arg2 = (Dali::BaseHandle *)jarg2;
18625   if (!arg2) {
18626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18627     return 0;
18628   }
18629   {
18630     try {
18631       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18632     } catch (std::out_of_range& e) {
18633       {
18634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18635       };
18636     } catch (std::exception& e) {
18637       {
18638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18639       };
18640     } catch (Dali::DaliException e) {
18641       {
18642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18643       };
18644     } catch (...) {
18645       {
18646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18647       };
18648     }
18649   }
18650
18651   jresult = result;
18652   return jresult;
18653 }
18654
18655
18656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18657   unsigned int jresult ;
18658   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18659   Dali::BaseHandle *arg2 = 0 ;
18660   bool result;
18661
18662   arg1 = (Dali::BaseHandle *)jarg1;
18663   arg2 = (Dali::BaseHandle *)jarg2;
18664   if (!arg2) {
18665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18666     return 0;
18667   }
18668   {
18669     try {
18670       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18671     } catch (std::out_of_range& e) {
18672       {
18673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18674       };
18675     } catch (std::exception& e) {
18676       {
18677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18678       };
18679     } catch (Dali::DaliException e) {
18680       {
18681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18682       };
18683     } catch (...) {
18684       {
18685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18686       };
18687     }
18688   }
18689
18690   jresult = result;
18691   return jresult;
18692 }
18693
18694
18695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18696   void * jresult ;
18697   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18698   Dali::RefObject *result = 0 ;
18699
18700   arg1 = (Dali::BaseHandle *)jarg1;
18701   {
18702     try {
18703       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18704     } catch (std::out_of_range& e) {
18705       {
18706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (std::exception& e) {
18709       {
18710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18711       };
18712     } catch (Dali::DaliException e) {
18713       {
18714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18715       };
18716     } catch (...) {
18717       {
18718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18719       };
18720     }
18721   }
18722
18723   jresult = (void *)result;
18724   return jresult;
18725 }
18726
18727
18728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18729   unsigned int jresult ;
18730   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18731   bool result;
18732
18733   arg1 = (Dali::BaseHandle *)jarg1;
18734   {
18735     try {
18736       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18737     } catch (std::out_of_range& e) {
18738       {
18739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18740       };
18741     } catch (std::exception& e) {
18742       {
18743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (Dali::DaliException e) {
18746       {
18747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18748       };
18749     } catch (...) {
18750       {
18751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18752       };
18753     }
18754   }
18755
18756   jresult = result;
18757   return jresult;
18758 }
18759
18760
18761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18762   unsigned int jresult ;
18763   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18764   Dali::BaseHandle *arg2 = 0 ;
18765   bool result;
18766
18767   arg1 = (Dali::BaseHandle *)jarg1;
18768   arg2 = (Dali::BaseHandle *)jarg2;
18769   if (!arg2) {
18770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18771     return 0;
18772   }
18773   {
18774     try {
18775       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18776     } catch (std::out_of_range& e) {
18777       {
18778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18779       };
18780     } catch (std::exception& e) {
18781       {
18782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18783       };
18784     } catch (Dali::DaliException e) {
18785       {
18786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18787       };
18788     } catch (...) {
18789       {
18790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18791       };
18792     }
18793   }
18794
18795   jresult = result;
18796   return jresult;
18797 }
18798
18799
18800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18801   unsigned int jresult ;
18802   Dali::BaseHandle *arg1 = 0 ;
18803   Dali::BaseHandle *arg2 = 0 ;
18804   bool result;
18805
18806   arg1 = (Dali::BaseHandle *)jarg1;
18807   if (!arg1) {
18808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18809     return 0;
18810   }
18811   arg2 = (Dali::BaseHandle *)jarg2;
18812   if (!arg2) {
18813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18814     return 0;
18815   }
18816   {
18817     try {
18818       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18819     } catch (std::out_of_range& e) {
18820       {
18821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (std::exception& e) {
18824       {
18825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18826       };
18827     } catch (Dali::DaliException e) {
18828       {
18829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18830       };
18831     } catch (...) {
18832       {
18833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18834       };
18835     }
18836   }
18837
18838   jresult = result;
18839   return jresult;
18840 }
18841
18842
18843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18844   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18845
18846   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18847   {
18848     try {
18849       delete arg1;
18850     } catch (std::out_of_range& e) {
18851       {
18852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18853       };
18854     } catch (std::exception& e) {
18855       {
18856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18857       };
18858     } catch (Dali::DaliException e) {
18859       {
18860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18861       };
18862     } catch (...) {
18863       {
18864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18865       };
18866     }
18867   }
18868
18869 }
18870
18871
18872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18873   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18874   SlotObserver *arg2 = (SlotObserver *) 0 ;
18875   CallbackBase *arg3 = (CallbackBase *) 0 ;
18876
18877   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18878   arg2 = (SlotObserver *)jarg2;
18879   arg3 = (CallbackBase *)jarg3;
18880   {
18881     try {
18882       (arg1)->SignalConnected(arg2,arg3);
18883     } catch (std::out_of_range& e) {
18884       {
18885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18886       };
18887     } catch (std::exception& e) {
18888       {
18889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18890       };
18891     } catch (Dali::DaliException e) {
18892       {
18893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18894       };
18895     } catch (...) {
18896       {
18897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18898       };
18899     }
18900   }
18901
18902 }
18903
18904
18905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18906   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18907
18908   arg1 = (Dali::SignalObserver *)jarg1;
18909   {
18910     try {
18911       delete arg1;
18912     } catch (std::out_of_range& e) {
18913       {
18914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18915       };
18916     } catch (std::exception& e) {
18917       {
18918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18919       };
18920     } catch (Dali::DaliException e) {
18921       {
18922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18923       };
18924     } catch (...) {
18925       {
18926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18927       };
18928     }
18929   }
18930
18931 }
18932
18933
18934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18935   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18936   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18937   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18938
18939   arg1 = (Dali::SignalObserver *)jarg1;
18940   arg2 = (Dali::SlotObserver *)jarg2;
18941   arg3 = (Dali::CallbackBase *)jarg3;
18942   {
18943     try {
18944       (arg1)->SignalDisconnected(arg2,arg3);
18945     } catch (std::out_of_range& e) {
18946       {
18947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18948       };
18949     } catch (std::exception& e) {
18950       {
18951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18952       };
18953     } catch (Dali::DaliException e) {
18954       {
18955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18956       };
18957     } catch (...) {
18958       {
18959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18960       };
18961     }
18962   }
18963
18964 }
18965
18966
18967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18968   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18969
18970   arg1 = (Dali::SlotObserver *)jarg1;
18971   {
18972     try {
18973       delete arg1;
18974     } catch (std::out_of_range& e) {
18975       {
18976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18977       };
18978     } catch (std::exception& e) {
18979       {
18980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18981       };
18982     } catch (Dali::DaliException e) {
18983       {
18984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18985       };
18986     } catch (...) {
18987       {
18988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18989       };
18990     }
18991   }
18992
18993 }
18994
18995
18996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18997   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18998   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18999
19000   arg1 = (Dali::SlotObserver *)jarg1;
19001   arg2 = (Dali::CallbackBase *)jarg2;
19002   {
19003     try {
19004       (arg1)->SlotDisconnected(arg2);
19005     } catch (std::out_of_range& e) {
19006       {
19007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19008       };
19009     } catch (std::exception& e) {
19010       {
19011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19012       };
19013     } catch (Dali::DaliException e) {
19014       {
19015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19016       };
19017     } catch (...) {
19018       {
19019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19020       };
19021     }
19022   }
19023
19024 }
19025
19026
19027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19028   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19029
19030   arg1 = (Dali::ConnectionTracker *)jarg1;
19031   {
19032     try {
19033       delete arg1;
19034     } catch (std::out_of_range& e) {
19035       {
19036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19037       };
19038     } catch (std::exception& e) {
19039       {
19040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19041       };
19042     } catch (Dali::DaliException e) {
19043       {
19044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19045       };
19046     } catch (...) {
19047       {
19048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19049       };
19050     }
19051   }
19052
19053 }
19054
19055
19056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19057   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19058
19059   arg1 = (Dali::ConnectionTracker *)jarg1;
19060   {
19061     try {
19062       (arg1)->DisconnectAll();
19063     } catch (std::out_of_range& e) {
19064       {
19065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19066       };
19067     } catch (std::exception& e) {
19068       {
19069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19070       };
19071     } catch (Dali::DaliException e) {
19072       {
19073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19074       };
19075     } catch (...) {
19076       {
19077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19078       };
19079     }
19080   }
19081
19082 }
19083
19084
19085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19086   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19087   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19088   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19089
19090   arg1 = (Dali::ConnectionTracker *)jarg1;
19091   arg2 = (Dali::SlotObserver *)jarg2;
19092   arg3 = (Dali::CallbackBase *)jarg3;
19093   {
19094     try {
19095       (arg1)->SignalConnected(arg2,arg3);
19096     } catch (std::out_of_range& e) {
19097       {
19098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19099       };
19100     } catch (std::exception& e) {
19101       {
19102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19103       };
19104     } catch (Dali::DaliException e) {
19105       {
19106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19107       };
19108     } catch (...) {
19109       {
19110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19111       };
19112     }
19113   }
19114
19115 }
19116
19117
19118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19119   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19120   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19121   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19122
19123   arg1 = (Dali::ConnectionTracker *)jarg1;
19124   arg2 = (Dali::SlotObserver *)jarg2;
19125   arg3 = (Dali::CallbackBase *)jarg3;
19126   {
19127     try {
19128       (arg1)->SignalDisconnected(arg2,arg3);
19129     } catch (std::out_of_range& e) {
19130       {
19131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19132       };
19133     } catch (std::exception& e) {
19134       {
19135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19136       };
19137     } catch (Dali::DaliException e) {
19138       {
19139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19140       };
19141     } catch (...) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19144       };
19145     }
19146   }
19147
19148 }
19149
19150
19151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19152   unsigned long jresult ;
19153   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19154   std::size_t result;
19155
19156   arg1 = (Dali::ConnectionTracker *)jarg1;
19157   {
19158     try {
19159       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19160     } catch (std::out_of_range& e) {
19161       {
19162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (std::exception& e) {
19165       {
19166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19167       };
19168     } catch (Dali::DaliException e) {
19169       {
19170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19171       };
19172     } catch (...) {
19173       {
19174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19175       };
19176     }
19177   }
19178
19179   jresult = (unsigned long)result;
19180   return jresult;
19181 }
19182
19183
19184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19185   void * jresult ;
19186   Dali::ObjectRegistry *result = 0 ;
19187
19188   {
19189     try {
19190       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19191     } catch (std::out_of_range& e) {
19192       {
19193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (std::exception& e) {
19196       {
19197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19198       };
19199     } catch (Dali::DaliException e) {
19200       {
19201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19202       };
19203     } catch (...) {
19204       {
19205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19206       };
19207     }
19208   }
19209
19210   jresult = (void *)result;
19211   return jresult;
19212 }
19213
19214
19215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19216   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19217
19218   arg1 = (Dali::ObjectRegistry *)jarg1;
19219   {
19220     try {
19221       delete arg1;
19222     } catch (std::out_of_range& e) {
19223       {
19224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19225       };
19226     } catch (std::exception& e) {
19227       {
19228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19229       };
19230     } catch (Dali::DaliException e) {
19231       {
19232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19233       };
19234     } catch (...) {
19235       {
19236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19237       };
19238     }
19239   }
19240
19241 }
19242
19243
19244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19245   void * jresult ;
19246   Dali::ObjectRegistry *arg1 = 0 ;
19247   Dali::ObjectRegistry *result = 0 ;
19248
19249   arg1 = (Dali::ObjectRegistry *)jarg1;
19250   if (!arg1) {
19251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19252     return 0;
19253   }
19254   {
19255     try {
19256       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19257     } catch (std::out_of_range& e) {
19258       {
19259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (std::exception& e) {
19262       {
19263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19264       };
19265     } catch (Dali::DaliException e) {
19266       {
19267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19268       };
19269     } catch (...) {
19270       {
19271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19272       };
19273     }
19274   }
19275
19276   jresult = (void *)result;
19277   return jresult;
19278 }
19279
19280
19281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19282   void * jresult ;
19283   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19284   Dali::ObjectRegistry *arg2 = 0 ;
19285   Dali::ObjectRegistry *result = 0 ;
19286
19287   arg1 = (Dali::ObjectRegistry *)jarg1;
19288   arg2 = (Dali::ObjectRegistry *)jarg2;
19289   if (!arg2) {
19290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19291     return 0;
19292   }
19293   {
19294     try {
19295       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19296     } catch (std::out_of_range& e) {
19297       {
19298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19299       };
19300     } catch (std::exception& e) {
19301       {
19302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19303       };
19304     } catch (Dali::DaliException e) {
19305       {
19306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19307       };
19308     } catch (...) {
19309       {
19310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19311       };
19312     }
19313   }
19314
19315   jresult = (void *)result;
19316   return jresult;
19317 }
19318
19319
19320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19321   void * jresult ;
19322   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19323   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19324
19325   arg1 = (Dali::ObjectRegistry *)jarg1;
19326   {
19327     try {
19328       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19329     } catch (std::out_of_range& e) {
19330       {
19331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19332       };
19333     } catch (std::exception& e) {
19334       {
19335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19336       };
19337     } catch (Dali::DaliException e) {
19338       {
19339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19340       };
19341     } catch (...) {
19342       {
19343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19344       };
19345     }
19346   }
19347
19348   jresult = (void *)result;
19349   return jresult;
19350 }
19351
19352
19353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19354   void * jresult ;
19355   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19356   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19357
19358   arg1 = (Dali::ObjectRegistry *)jarg1;
19359   {
19360     try {
19361       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19362     } catch (std::out_of_range& e) {
19363       {
19364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19365       };
19366     } catch (std::exception& e) {
19367       {
19368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19369       };
19370     } catch (Dali::DaliException e) {
19371       {
19372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19373       };
19374     } catch (...) {
19375       {
19376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19377       };
19378     }
19379   }
19380
19381   jresult = (void *)result;
19382   return jresult;
19383 }
19384
19385
19386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19387   void * jresult ;
19388   Dali::PropertyCondition *result = 0 ;
19389
19390   {
19391     try {
19392       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19393     } catch (std::out_of_range& e) {
19394       {
19395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19396       };
19397     } catch (std::exception& e) {
19398       {
19399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19400       };
19401     } catch (Dali::DaliException e) {
19402       {
19403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19404       };
19405     } catch (...) {
19406       {
19407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19408       };
19409     }
19410   }
19411
19412   jresult = (void *)result;
19413   return jresult;
19414 }
19415
19416
19417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19418   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19419
19420   arg1 = (Dali::PropertyCondition *)jarg1;
19421   {
19422     try {
19423       delete arg1;
19424     } catch (std::out_of_range& e) {
19425       {
19426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19427       };
19428     } catch (std::exception& e) {
19429       {
19430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19431       };
19432     } catch (Dali::DaliException e) {
19433       {
19434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19435       };
19436     } catch (...) {
19437       {
19438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19439       };
19440     }
19441   }
19442
19443 }
19444
19445
19446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19447   void * jresult ;
19448   Dali::PropertyCondition *arg1 = 0 ;
19449   Dali::PropertyCondition *result = 0 ;
19450
19451   arg1 = (Dali::PropertyCondition *)jarg1;
19452   if (!arg1) {
19453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19454     return 0;
19455   }
19456   {
19457     try {
19458       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19459     } catch (std::out_of_range& e) {
19460       {
19461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19462       };
19463     } catch (std::exception& e) {
19464       {
19465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19466       };
19467     } catch (Dali::DaliException e) {
19468       {
19469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19470       };
19471     } catch (...) {
19472       {
19473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19474       };
19475     }
19476   }
19477
19478   jresult = (void *)result;
19479   return jresult;
19480 }
19481
19482
19483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19484   void * jresult ;
19485   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19486   Dali::PropertyCondition *arg2 = 0 ;
19487   Dali::PropertyCondition *result = 0 ;
19488
19489   arg1 = (Dali::PropertyCondition *)jarg1;
19490   arg2 = (Dali::PropertyCondition *)jarg2;
19491   if (!arg2) {
19492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19493     return 0;
19494   }
19495   {
19496     try {
19497       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19498     } catch (std::out_of_range& e) {
19499       {
19500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19501       };
19502     } catch (std::exception& e) {
19503       {
19504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19505       };
19506     } catch (Dali::DaliException e) {
19507       {
19508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19509       };
19510     } catch (...) {
19511       {
19512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19513       };
19514     }
19515   }
19516
19517   jresult = (void *)result;
19518   return jresult;
19519 }
19520
19521
19522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19523   unsigned long jresult ;
19524   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19525   std::size_t result;
19526
19527   arg1 = (Dali::PropertyCondition *)jarg1;
19528   {
19529     try {
19530       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19531     } catch (std::out_of_range& e) {
19532       {
19533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19534       };
19535     } catch (std::exception& e) {
19536       {
19537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (...) {
19540       {
19541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19542       };
19543     }
19544   }
19545   jresult = (unsigned long)result;
19546   return jresult;
19547 }
19548
19549
19550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19551   float jresult ;
19552   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19553   std::size_t arg2 ;
19554   float result;
19555
19556   arg1 = (Dali::PropertyCondition *)jarg1;
19557   arg2 = (std::size_t)jarg2;
19558   {
19559     try {
19560       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19561     } catch (std::out_of_range& e) {
19562       {
19563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19564       };
19565     } catch (std::exception& e) {
19566       {
19567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19568       };
19569     } catch (...) {
19570       {
19571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19572       };
19573     }
19574   }
19575   jresult = result;
19576   return jresult;
19577 }
19578
19579
19580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19581   void * jresult ;
19582   float arg1 ;
19583   Dali::PropertyCondition result;
19584
19585   arg1 = (float)jarg1;
19586   {
19587     try {
19588       result = Dali::LessThanCondition(arg1);
19589     } catch (std::out_of_range& e) {
19590       {
19591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (std::exception& e) {
19594       {
19595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19596       };
19597     } catch (Dali::DaliException e) {
19598       {
19599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19600       };
19601     } catch (...) {
19602       {
19603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19604       };
19605     }
19606   }
19607
19608   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19609   return jresult;
19610 }
19611
19612
19613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19614   void * jresult ;
19615   float arg1 ;
19616   Dali::PropertyCondition result;
19617
19618   arg1 = (float)jarg1;
19619   {
19620     try {
19621       result = Dali::GreaterThanCondition(arg1);
19622     } catch (std::out_of_range& e) {
19623       {
19624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (std::exception& e) {
19627       {
19628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19629       };
19630     } catch (Dali::DaliException e) {
19631       {
19632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19633       };
19634     } catch (...) {
19635       {
19636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19637       };
19638     }
19639   }
19640
19641   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19642   return jresult;
19643 }
19644
19645
19646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19647   void * jresult ;
19648   float arg1 ;
19649   float arg2 ;
19650   Dali::PropertyCondition result;
19651
19652   arg1 = (float)jarg1;
19653   arg2 = (float)jarg2;
19654   {
19655     try {
19656       result = Dali::InsideCondition(arg1,arg2);
19657     } catch (std::out_of_range& e) {
19658       {
19659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19660       };
19661     } catch (std::exception& e) {
19662       {
19663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19664       };
19665     } catch (Dali::DaliException e) {
19666       {
19667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19668       };
19669     } catch (...) {
19670       {
19671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19672       };
19673     }
19674   }
19675
19676   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19677   return jresult;
19678 }
19679
19680
19681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19682   void * jresult ;
19683   float arg1 ;
19684   float arg2 ;
19685   Dali::PropertyCondition result;
19686
19687   arg1 = (float)jarg1;
19688   arg2 = (float)jarg2;
19689   {
19690     try {
19691       result = Dali::OutsideCondition(arg1,arg2);
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19699       };
19700     } catch (Dali::DaliException e) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19703       };
19704     } catch (...) {
19705       {
19706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19707       };
19708     }
19709   }
19710
19711   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19712   return jresult;
19713 }
19714
19715
19716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19717   void * jresult ;
19718   float arg1 ;
19719   float arg2 ;
19720   Dali::PropertyCondition result;
19721
19722   arg1 = (float)jarg1;
19723   arg2 = (float)jarg2;
19724   {
19725     try {
19726       result = Dali::StepCondition(arg1,arg2);
19727     } catch (std::out_of_range& e) {
19728       {
19729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (std::exception& e) {
19732       {
19733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19734       };
19735     } catch (Dali::DaliException e) {
19736       {
19737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19738       };
19739     } catch (...) {
19740       {
19741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19742       };
19743     }
19744   }
19745
19746   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19747   return jresult;
19748 }
19749
19750
19751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19752   void * jresult ;
19753   float arg1 ;
19754   Dali::PropertyCondition result;
19755
19756   arg1 = (float)jarg1;
19757   {
19758     try {
19759       result = Dali::StepCondition(arg1);
19760     } catch (std::out_of_range& e) {
19761       {
19762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (std::exception& e) {
19765       {
19766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19767       };
19768     } catch (Dali::DaliException e) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19771       };
19772     } catch (...) {
19773       {
19774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19775       };
19776     }
19777   }
19778
19779   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19780   return jresult;
19781 }
19782
19783
19784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19785   void * jresult ;
19786   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19787   Dali::PropertyCondition result;
19788
19789   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19790   if (!arg1) {
19791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19792     return 0;
19793   }
19794   {
19795     try {
19796       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (Dali::DaliException e) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19808       };
19809     } catch (...) {
19810       {
19811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19812       };
19813     }
19814   }
19815
19816   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19817   return jresult;
19818 }
19819
19820
19821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19822   void * jresult ;
19823   Dali::PropertyNotification *result = 0 ;
19824
19825   {
19826     try {
19827       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19828     } catch (std::out_of_range& e) {
19829       {
19830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19831       };
19832     } catch (std::exception& e) {
19833       {
19834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19835       };
19836     } catch (Dali::DaliException e) {
19837       {
19838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19839       };
19840     } catch (...) {
19841       {
19842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19843       };
19844     }
19845   }
19846
19847   jresult = (void *)result;
19848   return jresult;
19849 }
19850
19851
19852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19853   void * jresult ;
19854   Dali::BaseHandle arg1 ;
19855   Dali::BaseHandle *argp1 ;
19856   Dali::PropertyNotification result;
19857
19858   argp1 = (Dali::BaseHandle *)jarg1;
19859   if (!argp1) {
19860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19861     return 0;
19862   }
19863   arg1 = *argp1;
19864   {
19865     try {
19866       result = Dali::PropertyNotification::DownCast(arg1);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19874       };
19875     } catch (Dali::DaliException e) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19878       };
19879     } catch (...) {
19880       {
19881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19882       };
19883     }
19884   }
19885
19886   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19887   return jresult;
19888 }
19889
19890
19891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19892   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19893
19894   arg1 = (Dali::PropertyNotification *)jarg1;
19895   {
19896     try {
19897       delete arg1;
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19913       };
19914     }
19915   }
19916
19917 }
19918
19919
19920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19921   void * jresult ;
19922   Dali::PropertyNotification *arg1 = 0 ;
19923   Dali::PropertyNotification *result = 0 ;
19924
19925   arg1 = (Dali::PropertyNotification *)jarg1;
19926   if (!arg1) {
19927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19928     return 0;
19929   }
19930   {
19931     try {
19932       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19933     } catch (std::out_of_range& e) {
19934       {
19935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19936       };
19937     } catch (std::exception& e) {
19938       {
19939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19940       };
19941     } catch (Dali::DaliException e) {
19942       {
19943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19944       };
19945     } catch (...) {
19946       {
19947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19948       };
19949     }
19950   }
19951
19952   jresult = (void *)result;
19953   return jresult;
19954 }
19955
19956
19957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19958   void * jresult ;
19959   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19960   Dali::PropertyNotification *arg2 = 0 ;
19961   Dali::PropertyNotification *result = 0 ;
19962
19963   arg1 = (Dali::PropertyNotification *)jarg1;
19964   arg2 = (Dali::PropertyNotification *)jarg2;
19965   if (!arg2) {
19966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19967     return 0;
19968   }
19969   {
19970     try {
19971       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19972     } catch (std::out_of_range& e) {
19973       {
19974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19975       };
19976     } catch (std::exception& e) {
19977       {
19978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19979       };
19980     } catch (Dali::DaliException e) {
19981       {
19982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19983       };
19984     } catch (...) {
19985       {
19986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19987       };
19988     }
19989   }
19990
19991   jresult = (void *)result;
19992   return jresult;
19993 }
19994
19995
19996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19997   void * jresult ;
19998   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19999   Dali::PropertyCondition result;
20000
20001   arg1 = (Dali::PropertyNotification *)jarg1;
20002   {
20003     try {
20004       result = (arg1)->GetCondition();
20005     } catch (std::out_of_range& e) {
20006       {
20007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20008       };
20009     } catch (std::exception& e) {
20010       {
20011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20012       };
20013     } catch (Dali::DaliException e) {
20014       {
20015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20016       };
20017     } catch (...) {
20018       {
20019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20020       };
20021     }
20022   }
20023
20024   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20025   return jresult;
20026 }
20027
20028
20029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20030   void * jresult ;
20031   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20032   Dali::Handle result;
20033
20034   arg1 = (Dali::PropertyNotification *)jarg1;
20035   {
20036     try {
20037       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20038     } catch (std::out_of_range& e) {
20039       {
20040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20041       };
20042     } catch (std::exception& e) {
20043       {
20044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20045       };
20046     } catch (Dali::DaliException e) {
20047       {
20048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20049       };
20050     } catch (...) {
20051       {
20052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20053       };
20054     }
20055   }
20056
20057   jresult = new Dali::Handle((const Dali::Handle &)result);
20058   return jresult;
20059 }
20060
20061
20062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20063   int jresult ;
20064   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20065   Dali::Property::Index result;
20066
20067   arg1 = (Dali::PropertyNotification *)jarg1;
20068   {
20069     try {
20070       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20071     } catch (std::out_of_range& e) {
20072       {
20073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20074       };
20075     } catch (std::exception& e) {
20076       {
20077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20078       };
20079     } catch (Dali::DaliException e) {
20080       {
20081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20082       };
20083     } catch (...) {
20084       {
20085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20086       };
20087     }
20088   }
20089
20090   jresult = result;
20091   return jresult;
20092 }
20093
20094
20095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20096   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20097   Dali::PropertyNotification::NotifyMode arg2 ;
20098
20099   arg1 = (Dali::PropertyNotification *)jarg1;
20100   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20101   {
20102     try {
20103       (arg1)->SetNotifyMode(arg2);
20104     } catch (std::out_of_range& e) {
20105       {
20106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20107       };
20108     } catch (std::exception& e) {
20109       {
20110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20111       };
20112     } catch (Dali::DaliException e) {
20113       {
20114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20115       };
20116     } catch (...) {
20117       {
20118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20119       };
20120     }
20121   }
20122
20123 }
20124
20125
20126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20127   int jresult ;
20128   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20129   Dali::PropertyNotification::NotifyMode result;
20130
20131   arg1 = (Dali::PropertyNotification *)jarg1;
20132   {
20133     try {
20134       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20135     } catch (std::out_of_range& e) {
20136       {
20137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20138       };
20139     } catch (std::exception& e) {
20140       {
20141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20142       };
20143     } catch (Dali::DaliException e) {
20144       {
20145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20146       };
20147     } catch (...) {
20148       {
20149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20150       };
20151     }
20152   }
20153
20154   jresult = (int)result;
20155   return jresult;
20156 }
20157
20158
20159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20160   unsigned int jresult ;
20161   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20162   bool result;
20163
20164   arg1 = (Dali::PropertyNotification *)jarg1;
20165   {
20166     try {
20167       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20168     } catch (std::out_of_range& e) {
20169       {
20170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20171       };
20172     } catch (std::exception& e) {
20173       {
20174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20175       };
20176     } catch (Dali::DaliException e) {
20177       {
20178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20179       };
20180     } catch (...) {
20181       {
20182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20183       };
20184     }
20185   }
20186
20187   jresult = result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20193   void * jresult ;
20194   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20195   Dali::PropertyNotifySignalType *result = 0 ;
20196
20197   arg1 = (Dali::PropertyNotification *)jarg1;
20198   {
20199     try {
20200       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20201     } catch (std::out_of_range& e) {
20202       {
20203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20204       };
20205     } catch (std::exception& e) {
20206       {
20207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20208       };
20209     } catch (Dali::DaliException e) {
20210       {
20211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20212       };
20213     } catch (...) {
20214       {
20215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20216       };
20217     }
20218   }
20219
20220   jresult = (void *)result;
20221   return jresult;
20222 }
20223
20224
20225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20226   void * jresult ;
20227   Dali::Handle *result = 0 ;
20228
20229   {
20230     try {
20231       result = (Dali::Handle *)new Dali::Handle();
20232     } catch (std::out_of_range& e) {
20233       {
20234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20235       };
20236     } catch (std::exception& e) {
20237       {
20238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20239       };
20240     } catch (Dali::DaliException e) {
20241       {
20242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20243       };
20244     } catch (...) {
20245       {
20246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20247       };
20248     }
20249   }
20250
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20257   void * jresult ;
20258   Dali::Handle result;
20259
20260   {
20261     try {
20262       result = Dali::Handle::New();
20263     } catch (std::out_of_range& e) {
20264       {
20265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20266       };
20267     } catch (std::exception& e) {
20268       {
20269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20270       };
20271     } catch (Dali::DaliException e) {
20272       {
20273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20274       };
20275     } catch (...) {
20276       {
20277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20278       };
20279     }
20280   }
20281
20282   jresult = new Dali::Handle((const Dali::Handle &)result);
20283   return jresult;
20284 }
20285
20286
20287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20288   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20289
20290   arg1 = (Dali::Handle *)jarg1;
20291   {
20292     try {
20293       delete arg1;
20294     } catch (std::out_of_range& e) {
20295       {
20296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20297       };
20298     } catch (std::exception& e) {
20299       {
20300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20301       };
20302     } catch (Dali::DaliException e) {
20303       {
20304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20305       };
20306     } catch (...) {
20307       {
20308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20309       };
20310     }
20311   }
20312
20313 }
20314
20315
20316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20317   void * jresult ;
20318   Dali::Handle *arg1 = 0 ;
20319   Dali::Handle *result = 0 ;
20320
20321   arg1 = (Dali::Handle *)jarg1;
20322   if (!arg1) {
20323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20324     return 0;
20325   }
20326   {
20327     try {
20328       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20329     } catch (std::out_of_range& e) {
20330       {
20331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20332       };
20333     } catch (std::exception& e) {
20334       {
20335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20336       };
20337     } catch (Dali::DaliException e) {
20338       {
20339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20340       };
20341     } catch (...) {
20342       {
20343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20344       };
20345     }
20346   }
20347
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20354   void * jresult ;
20355   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20356   Dali::Handle *arg2 = 0 ;
20357   Dali::Handle *result = 0 ;
20358
20359   arg1 = (Dali::Handle *)jarg1;
20360   arg2 = (Dali::Handle *)jarg2;
20361   if (!arg2) {
20362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20363     return 0;
20364   }
20365   {
20366     try {
20367       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20368     } catch (std::out_of_range& e) {
20369       {
20370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20371       };
20372     } catch (std::exception& e) {
20373       {
20374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20375       };
20376     } catch (Dali::DaliException e) {
20377       {
20378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20379       };
20380     } catch (...) {
20381       {
20382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20383       };
20384     }
20385   }
20386
20387   jresult = (void *)result;
20388   return jresult;
20389 }
20390
20391
20392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20393   void * jresult ;
20394   Dali::BaseHandle arg1 ;
20395   Dali::BaseHandle *argp1 ;
20396   Dali::Handle result;
20397
20398   argp1 = (Dali::BaseHandle *)jarg1;
20399   if (!argp1) {
20400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20401     return 0;
20402   }
20403   arg1 = *argp1;
20404   {
20405     try {
20406       result = Dali::Handle::DownCast(arg1);
20407     } catch (std::out_of_range& e) {
20408       {
20409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20410       };
20411     } catch (std::exception& e) {
20412       {
20413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20414       };
20415     } catch (Dali::DaliException e) {
20416       {
20417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20418       };
20419     } catch (...) {
20420       {
20421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20422       };
20423     }
20424   }
20425
20426   jresult = new Dali::Handle((const Dali::Handle &)result);
20427   return jresult;
20428 }
20429
20430
20431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20432   unsigned int jresult ;
20433   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20434   Dali::Handle::Capability arg2 ;
20435   bool result;
20436
20437   arg1 = (Dali::Handle *)jarg1;
20438   arg2 = (Dali::Handle::Capability)jarg2;
20439   {
20440     try {
20441       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20442     } catch (std::out_of_range& e) {
20443       {
20444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20445       };
20446     } catch (std::exception& e) {
20447       {
20448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20449       };
20450     } catch (Dali::DaliException e) {
20451       {
20452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20453       };
20454     } catch (...) {
20455       {
20456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20457       };
20458     }
20459   }
20460
20461   jresult = result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20467   unsigned int jresult ;
20468   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20469   unsigned int result;
20470
20471   arg1 = (Dali::Handle *)jarg1;
20472   {
20473     try {
20474       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20475     } catch (std::out_of_range& e) {
20476       {
20477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20478       };
20479     } catch (std::exception& e) {
20480       {
20481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20482       };
20483     } catch (Dali::DaliException e) {
20484       {
20485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20486       };
20487     } catch (...) {
20488       {
20489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20490       };
20491     }
20492   }
20493
20494   jresult = result;
20495   return jresult;
20496 }
20497
20498
20499 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20500   char * jresult ;
20501   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20502   Dali::Property::Index arg2 ;
20503   std::string result;
20504
20505   arg1 = (Dali::Handle *)jarg1;
20506   arg2 = (Dali::Property::Index)jarg2;
20507   {
20508     try {
20509       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20510     } catch (std::out_of_range& e) {
20511       {
20512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20513       };
20514     } catch (std::exception& e) {
20515       {
20516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20517       };
20518     } catch (Dali::DaliException e) {
20519       {
20520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20521       };
20522     } catch (...) {
20523       {
20524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20525       };
20526     }
20527   }
20528
20529   jresult = SWIG_csharp_string_callback((&result)->c_str());
20530   return jresult;
20531 }
20532
20533
20534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20535   int jresult ;
20536   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20537   std::string *arg2 = 0 ;
20538   Dali::Property::Index result;
20539
20540   arg1 = (Dali::Handle *)jarg1;
20541   if (!jarg2) {
20542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20543     return 0;
20544   }
20545   std::string arg2_str(jarg2);
20546   arg2 = &arg2_str;
20547   {
20548     try {
20549       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20550     } catch (std::out_of_range& e) {
20551       {
20552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20553       };
20554     } catch (std::exception& e) {
20555       {
20556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (Dali::DaliException e) {
20559       {
20560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20561       };
20562     } catch (...) {
20563       {
20564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20565       };
20566     }
20567   }
20568
20569   jresult = result;
20570
20571   //argout typemap for const std::string&
20572
20573   return jresult;
20574 }
20575
20576
20577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20578   unsigned int jresult ;
20579   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20580   Dali::Property::Index arg2 ;
20581   bool result;
20582
20583   arg1 = (Dali::Handle *)jarg1;
20584   arg2 = (Dali::Property::Index)jarg2;
20585   {
20586     try {
20587       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20588     } catch (std::out_of_range& e) {
20589       {
20590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20591       };
20592     } catch (std::exception& e) {
20593       {
20594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20595       };
20596     } catch (Dali::DaliException e) {
20597       {
20598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20599       };
20600     } catch (...) {
20601       {
20602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20603       };
20604     }
20605   }
20606
20607   jresult = result;
20608   return jresult;
20609 }
20610
20611
20612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20613   unsigned int jresult ;
20614   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20615   Dali::Property::Index arg2 ;
20616   bool result;
20617
20618   arg1 = (Dali::Handle *)jarg1;
20619   arg2 = (Dali::Property::Index)jarg2;
20620   {
20621     try {
20622       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20623     } catch (std::out_of_range& e) {
20624       {
20625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20626       };
20627     } catch (std::exception& e) {
20628       {
20629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20630       };
20631     } catch (Dali::DaliException e) {
20632       {
20633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20634       };
20635     } catch (...) {
20636       {
20637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20638       };
20639     }
20640   }
20641
20642   jresult = result;
20643   return jresult;
20644 }
20645
20646
20647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20648   unsigned int jresult ;
20649   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20650   Dali::Property::Index arg2 ;
20651   bool result;
20652
20653   arg1 = (Dali::Handle *)jarg1;
20654   arg2 = (Dali::Property::Index)jarg2;
20655   {
20656     try {
20657       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20658     } catch (std::out_of_range& e) {
20659       {
20660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20661       };
20662     } catch (std::exception& e) {
20663       {
20664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20665       };
20666     } catch (Dali::DaliException e) {
20667       {
20668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20669       };
20670     } catch (...) {
20671       {
20672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20673       };
20674     }
20675   }
20676
20677   jresult = result;
20678   return jresult;
20679 }
20680
20681
20682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20683   int jresult ;
20684   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20685   Dali::Property::Index arg2 ;
20686   Dali::Property::Type result;
20687
20688   arg1 = (Dali::Handle *)jarg1;
20689   arg2 = (Dali::Property::Index)jarg2;
20690   {
20691     try {
20692       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (Dali::DaliException e) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711
20712   jresult = (int)result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20718   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20719   Dali::Property::Index arg2 ;
20720   Dali::Property::Value *arg3 = 0 ;
20721
20722   arg1 = (Dali::Handle *)jarg1;
20723   arg2 = (Dali::Property::Index)jarg2;
20724   arg3 = (Dali::Property::Value *)jarg3;
20725   if (!arg3) {
20726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20727     return ;
20728   }
20729   {
20730     try {
20731       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20732     } catch (std::out_of_range& e) {
20733       {
20734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20735       };
20736     } catch (std::exception& e) {
20737       {
20738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20739       };
20740     } catch (Dali::DaliException e) {
20741       {
20742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20743       };
20744     } catch (...) {
20745       {
20746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20747       };
20748     }
20749   }
20750
20751 }
20752
20753
20754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20755   int jresult ;
20756   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20757   std::string *arg2 = 0 ;
20758   Dali::Property::Value *arg3 = 0 ;
20759   Dali::Property::Index result;
20760
20761   arg1 = (Dali::Handle *)jarg1;
20762   if (!jarg2) {
20763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20764     return 0;
20765   }
20766   std::string arg2_str(jarg2);
20767   arg2 = &arg2_str;
20768   arg3 = (Dali::Property::Value *)jarg3;
20769   if (!arg3) {
20770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20771     return 0;
20772   }
20773   {
20774     try {
20775       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20776     } catch (std::out_of_range& e) {
20777       {
20778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (std::exception& e) {
20781       {
20782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20783       };
20784     } catch (Dali::DaliException e) {
20785       {
20786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20787       };
20788     } catch (...) {
20789       {
20790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20791       };
20792     }
20793   }
20794
20795   jresult = result;
20796
20797   //argout typemap for const std::string&
20798
20799   return jresult;
20800 }
20801
20802
20803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20804   int jresult ;
20805   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20806   std::string *arg2 = 0 ;
20807   Dali::Property::Value *arg3 = 0 ;
20808   Dali::Property::AccessMode arg4 ;
20809   Dali::Property::Index result;
20810
20811   arg1 = (Dali::Handle *)jarg1;
20812   if (!jarg2) {
20813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20814     return 0;
20815   }
20816   std::string arg2_str(jarg2);
20817   arg2 = &arg2_str;
20818   arg3 = (Dali::Property::Value *)jarg3;
20819   if (!arg3) {
20820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20821     return 0;
20822   }
20823   arg4 = (Dali::Property::AccessMode)jarg4;
20824   {
20825     try {
20826       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20827     } catch (std::out_of_range& e) {
20828       {
20829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20830       };
20831     } catch (std::exception& e) {
20832       {
20833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20834       };
20835     } catch (Dali::DaliException e) {
20836       {
20837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20838       };
20839     } catch (...) {
20840       {
20841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20842       };
20843     }
20844   }
20845
20846   jresult = result;
20847
20848   //argout typemap for const std::string&
20849
20850   return jresult;
20851 }
20852
20853
20854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20855   void * jresult ;
20856   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20857   Dali::Property::Index arg2 ;
20858   Dali::Property::Value result;
20859
20860   arg1 = (Dali::Handle *)jarg1;
20861   arg2 = (Dali::Property::Index)jarg2;
20862   {
20863     try {
20864       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20865     } catch (std::out_of_range& e) {
20866       {
20867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20868       };
20869     } catch (std::exception& e) {
20870       {
20871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (Dali::DaliException e) {
20874       {
20875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20876       };
20877     } catch (...) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20880       };
20881     }
20882   }
20883
20884   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20885   return jresult;
20886 }
20887
20888
20889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20890   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20891   Dali::Property::IndexContainer *arg2 = 0 ;
20892
20893   arg1 = (Dali::Handle *)jarg1;
20894   arg2 = (Dali::Property::IndexContainer *)jarg2;
20895   if (!arg2) {
20896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20897     return ;
20898   }
20899   {
20900     try {
20901       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20917       };
20918     }
20919   }
20920
20921 }
20922
20923
20924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20925   void * jresult ;
20926   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20927   Dali::Property::Index arg2 ;
20928   Dali::PropertyCondition *arg3 = 0 ;
20929   Dali::PropertyNotification result;
20930
20931   arg1 = (Dali::Handle *)jarg1;
20932   arg2 = (Dali::Property::Index)jarg2;
20933   arg3 = (Dali::PropertyCondition *)jarg3;
20934   if (!arg3) {
20935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20936     return 0;
20937   }
20938   {
20939     try {
20940       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20941     } catch (std::out_of_range& e) {
20942       {
20943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20944       };
20945     } catch (std::exception& e) {
20946       {
20947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20948       };
20949     } catch (Dali::DaliException e) {
20950       {
20951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20952       };
20953     } catch (...) {
20954       {
20955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20956       };
20957     }
20958   }
20959
20960   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20961   return jresult;
20962 }
20963
20964
20965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20966   void * jresult ;
20967   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20968   Dali::Property::Index arg2 ;
20969   int arg3 ;
20970   Dali::PropertyCondition *arg4 = 0 ;
20971   Dali::PropertyNotification result;
20972
20973   arg1 = (Dali::Handle *)jarg1;
20974   arg2 = (Dali::Property::Index)jarg2;
20975   arg3 = (int)jarg3;
20976   arg4 = (Dali::PropertyCondition *)jarg4;
20977   if (!arg4) {
20978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20979     return 0;
20980   }
20981   {
20982     try {
20983       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20984     } catch (std::out_of_range& e) {
20985       {
20986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20987       };
20988     } catch (std::exception& e) {
20989       {
20990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20991       };
20992     } catch (Dali::DaliException e) {
20993       {
20994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20995       };
20996     } catch (...) {
20997       {
20998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20999       };
21000     }
21001   }
21002
21003   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21004   return jresult;
21005 }
21006
21007
21008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21009   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21010   Dali::PropertyNotification arg2 ;
21011   Dali::PropertyNotification *argp2 ;
21012
21013   arg1 = (Dali::Handle *)jarg1;
21014   argp2 = (Dali::PropertyNotification *)jarg2;
21015   if (!argp2) {
21016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21017     return ;
21018   }
21019   arg2 = *argp2;
21020   {
21021     try {
21022       (arg1)->RemovePropertyNotification(arg2);
21023     } catch (std::out_of_range& e) {
21024       {
21025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21026       };
21027     } catch (std::exception& e) {
21028       {
21029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21030       };
21031     } catch (Dali::DaliException e) {
21032       {
21033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21034       };
21035     } catch (...) {
21036       {
21037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21038       };
21039     }
21040   }
21041
21042 }
21043
21044
21045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21046   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21047
21048   arg1 = (Dali::Handle *)jarg1;
21049   {
21050     try {
21051       (arg1)->RemovePropertyNotifications();
21052     } catch (std::out_of_range& e) {
21053       {
21054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21055       };
21056     } catch (std::exception& e) {
21057       {
21058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21059       };
21060     } catch (Dali::DaliException e) {
21061       {
21062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21063       };
21064     } catch (...) {
21065       {
21066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21067       };
21068     }
21069   }
21070
21071 }
21072
21073
21074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21075   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21076
21077   arg1 = (Dali::Handle *)jarg1;
21078   {
21079     try {
21080       (arg1)->RemoveConstraints();
21081     } catch (std::out_of_range& e) {
21082       {
21083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21084       };
21085     } catch (std::exception& e) {
21086       {
21087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21088       };
21089     } catch (Dali::DaliException e) {
21090       {
21091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21092       };
21093     } catch (...) {
21094       {
21095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21096       };
21097     }
21098   }
21099
21100 }
21101
21102
21103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21104   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21105   unsigned int arg2 ;
21106
21107   arg1 = (Dali::Handle *)jarg1;
21108   arg2 = (unsigned int)jarg2;
21109   {
21110     try {
21111       (arg1)->RemoveConstraints(arg2);
21112     } catch (std::out_of_range& e) {
21113       {
21114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21115       };
21116     } catch (std::exception& e) {
21117       {
21118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21119       };
21120     } catch (Dali::DaliException e) {
21121       {
21122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21123       };
21124     } catch (...) {
21125       {
21126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21127       };
21128     }
21129   }
21130
21131 }
21132
21133
21134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21135   int jresult ;
21136   Dali::Property::Index result;
21137
21138   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21139   jresult = result;
21140   return jresult;
21141 }
21142
21143
21144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21145   void * jresult ;
21146   Dali::Handle result;
21147
21148   {
21149     try {
21150       result = Dali::WeightObject::New();
21151     } catch (std::out_of_range& e) {
21152       {
21153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21154       };
21155     } catch (std::exception& e) {
21156       {
21157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21158       };
21159     } catch (Dali::DaliException e) {
21160       {
21161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21162       };
21163     } catch (...) {
21164       {
21165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21166       };
21167     }
21168   }
21169
21170   jresult = new Dali::Handle((const Dali::Handle &)result);
21171   return jresult;
21172 }
21173
21174
21175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21176   void * jresult ;
21177   Dali::TypeInfo *result = 0 ;
21178
21179   {
21180     try {
21181       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21182     } catch (std::out_of_range& e) {
21183       {
21184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21185       };
21186     } catch (std::exception& e) {
21187       {
21188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21189       };
21190     } catch (Dali::DaliException e) {
21191       {
21192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21193       };
21194     } catch (...) {
21195       {
21196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21197       };
21198     }
21199   }
21200
21201   jresult = (void *)result;
21202   return jresult;
21203 }
21204
21205
21206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21207   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21208
21209   arg1 = (Dali::TypeInfo *)jarg1;
21210   {
21211     try {
21212       delete arg1;
21213     } catch (std::out_of_range& e) {
21214       {
21215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21216       };
21217     } catch (std::exception& e) {
21218       {
21219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21220       };
21221     } catch (Dali::DaliException e) {
21222       {
21223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21224       };
21225     } catch (...) {
21226       {
21227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21228       };
21229     }
21230   }
21231
21232 }
21233
21234
21235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21236   void * jresult ;
21237   Dali::TypeInfo *arg1 = 0 ;
21238   Dali::TypeInfo *result = 0 ;
21239
21240   arg1 = (Dali::TypeInfo *)jarg1;
21241   if (!arg1) {
21242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21243     return 0;
21244   }
21245   {
21246     try {
21247       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21248     } catch (std::out_of_range& e) {
21249       {
21250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21251       };
21252     } catch (std::exception& e) {
21253       {
21254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (Dali::DaliException e) {
21257       {
21258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21259       };
21260     } catch (...) {
21261       {
21262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21263       };
21264     }
21265   }
21266
21267   jresult = (void *)result;
21268   return jresult;
21269 }
21270
21271
21272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21273   void * jresult ;
21274   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21275   Dali::TypeInfo *arg2 = 0 ;
21276   Dali::TypeInfo *result = 0 ;
21277
21278   arg1 = (Dali::TypeInfo *)jarg1;
21279   arg2 = (Dali::TypeInfo *)jarg2;
21280   if (!arg2) {
21281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21282     return 0;
21283   }
21284   {
21285     try {
21286       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21287     } catch (std::out_of_range& e) {
21288       {
21289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (std::exception& e) {
21292       {
21293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21294       };
21295     } catch (Dali::DaliException e) {
21296       {
21297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21298       };
21299     } catch (...) {
21300       {
21301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21302       };
21303     }
21304   }
21305
21306   jresult = (void *)result;
21307   return jresult;
21308 }
21309
21310
21311 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21312   char * jresult ;
21313   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21314   std::string *result = 0 ;
21315
21316   arg1 = (Dali::TypeInfo *)jarg1;
21317   {
21318     try {
21319       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21320     } catch (std::out_of_range& e) {
21321       {
21322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21323       };
21324     } catch (std::exception& e) {
21325       {
21326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21327       };
21328     } catch (Dali::DaliException e) {
21329       {
21330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21331       };
21332     } catch (...) {
21333       {
21334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21335       };
21336     }
21337   }
21338
21339   jresult = SWIG_csharp_string_callback(result->c_str());
21340   return jresult;
21341 }
21342
21343
21344 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21345   char * jresult ;
21346   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21347   std::string *result = 0 ;
21348
21349   arg1 = (Dali::TypeInfo *)jarg1;
21350   {
21351     try {
21352       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21353     } catch (std::out_of_range& e) {
21354       {
21355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21356       };
21357     } catch (std::exception& e) {
21358       {
21359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21360       };
21361     } catch (Dali::DaliException e) {
21362       {
21363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21364       };
21365     } catch (...) {
21366       {
21367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21368       };
21369     }
21370   }
21371
21372   jresult = SWIG_csharp_string_callback(result->c_str());
21373   return jresult;
21374 }
21375
21376
21377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21378   void * jresult ;
21379   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21380   Dali::BaseHandle result;
21381
21382   arg1 = (Dali::TypeInfo *)jarg1;
21383   {
21384     try {
21385       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21386     } catch (std::out_of_range& e) {
21387       {
21388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21389       };
21390     } catch (std::exception& e) {
21391       {
21392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21393       };
21394     } catch (Dali::DaliException e) {
21395       {
21396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21397       };
21398     } catch (...) {
21399       {
21400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21401       };
21402     }
21403   }
21404
21405   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21406   return jresult;
21407 }
21408
21409
21410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21411   unsigned long jresult ;
21412   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21413   size_t result;
21414
21415   arg1 = (Dali::TypeInfo *)jarg1;
21416   {
21417     try {
21418       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21419     } catch (std::out_of_range& e) {
21420       {
21421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21422       };
21423     } catch (std::exception& e) {
21424       {
21425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21426       };
21427     } catch (Dali::DaliException e) {
21428       {
21429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21430       };
21431     } catch (...) {
21432       {
21433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21434       };
21435     }
21436   }
21437
21438   jresult = (unsigned long)result;
21439   return jresult;
21440 }
21441
21442
21443 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21444   char * jresult ;
21445   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21446   size_t arg2 ;
21447   std::string result;
21448
21449   arg1 = (Dali::TypeInfo *)jarg1;
21450   arg2 = (size_t)jarg2;
21451   {
21452     try {
21453       result = (arg1)->GetActionName(arg2);
21454     } catch (std::out_of_range& e) {
21455       {
21456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21457       };
21458     } catch (std::exception& e) {
21459       {
21460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21461       };
21462     } catch (Dali::DaliException e) {
21463       {
21464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21465       };
21466     } catch (...) {
21467       {
21468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21469       };
21470     }
21471   }
21472
21473   jresult = SWIG_csharp_string_callback((&result)->c_str());
21474   return jresult;
21475 }
21476
21477
21478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21479   unsigned long jresult ;
21480   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21481   size_t result;
21482
21483   arg1 = (Dali::TypeInfo *)jarg1;
21484   {
21485     try {
21486       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21487     } catch (std::out_of_range& e) {
21488       {
21489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (std::exception& e) {
21492       {
21493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (Dali::DaliException e) {
21496       {
21497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21498       };
21499     } catch (...) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21502       };
21503     }
21504   }
21505
21506   jresult = (unsigned long)result;
21507   return jresult;
21508 }
21509
21510
21511 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21512   char * jresult ;
21513   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21514   size_t arg2 ;
21515   std::string result;
21516
21517   arg1 = (Dali::TypeInfo *)jarg1;
21518   arg2 = (size_t)jarg2;
21519   {
21520     try {
21521       result = (arg1)->GetSignalName(arg2);
21522     } catch (std::out_of_range& e) {
21523       {
21524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21525       };
21526     } catch (std::exception& e) {
21527       {
21528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21529       };
21530     } catch (Dali::DaliException e) {
21531       {
21532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21533       };
21534     } catch (...) {
21535       {
21536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21537       };
21538     }
21539   }
21540
21541   jresult = SWIG_csharp_string_callback((&result)->c_str());
21542   return jresult;
21543 }
21544
21545
21546 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21547   unsigned long jresult ;
21548   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21549   size_t result;
21550
21551   arg1 = (Dali::TypeInfo *)jarg1;
21552   {
21553     try {
21554       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21555     } catch (std::out_of_range& e) {
21556       {
21557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21558       };
21559     } catch (std::exception& e) {
21560       {
21561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21562       };
21563     } catch (Dali::DaliException e) {
21564       {
21565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21566       };
21567     } catch (...) {
21568       {
21569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21570       };
21571     }
21572   }
21573
21574   jresult = (unsigned long)result;
21575   return jresult;
21576 }
21577
21578
21579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21580   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21581   Dali::Property::IndexContainer *arg2 = 0 ;
21582
21583   arg1 = (Dali::TypeInfo *)jarg1;
21584   arg2 = (Dali::Property::IndexContainer *)jarg2;
21585   if (!arg2) {
21586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21587     return ;
21588   }
21589   {
21590     try {
21591       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21592     } catch (std::out_of_range& e) {
21593       {
21594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21595       };
21596     } catch (std::exception& e) {
21597       {
21598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21599       };
21600     } catch (Dali::DaliException e) {
21601       {
21602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21603       };
21604     } catch (...) {
21605       {
21606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21607       };
21608     }
21609   }
21610
21611 }
21612
21613
21614 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21615   char * jresult ;
21616   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21617   Dali::Property::Index arg2 ;
21618   std::string *result = 0 ;
21619
21620   arg1 = (Dali::TypeInfo *)jarg1;
21621   arg2 = (Dali::Property::Index)jarg2;
21622   {
21623     try {
21624       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21625     } catch (std::out_of_range& e) {
21626       {
21627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21628       };
21629     } catch (std::exception& e) {
21630       {
21631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21632       };
21633     } catch (Dali::DaliException e) {
21634       {
21635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21636       };
21637     } catch (...) {
21638       {
21639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21640       };
21641     }
21642   }
21643
21644   jresult = SWIG_csharp_string_callback(result->c_str());
21645   return jresult;
21646 }
21647
21648
21649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21650   void * jresult ;
21651   Dali::TypeRegistry result;
21652
21653   {
21654     try {
21655       result = Dali::TypeRegistry::Get();
21656     } catch (std::out_of_range& e) {
21657       {
21658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21659       };
21660     } catch (std::exception& e) {
21661       {
21662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21663       };
21664     } catch (Dali::DaliException e) {
21665       {
21666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21667       };
21668     } catch (...) {
21669       {
21670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21671       };
21672     }
21673   }
21674
21675   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21676   return jresult;
21677 }
21678
21679
21680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21681   void * jresult ;
21682   Dali::TypeRegistry *result = 0 ;
21683
21684   {
21685     try {
21686       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21687     } catch (std::out_of_range& e) {
21688       {
21689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21690       };
21691     } catch (std::exception& e) {
21692       {
21693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21694       };
21695     } catch (Dali::DaliException e) {
21696       {
21697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21698       };
21699     } catch (...) {
21700       {
21701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21702       };
21703     }
21704   }
21705
21706   jresult = (void *)result;
21707   return jresult;
21708 }
21709
21710
21711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21712   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21713
21714   arg1 = (Dali::TypeRegistry *)jarg1;
21715   {
21716     try {
21717       delete arg1;
21718     } catch (std::out_of_range& e) {
21719       {
21720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21721       };
21722     } catch (std::exception& e) {
21723       {
21724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21725       };
21726     } catch (Dali::DaliException e) {
21727       {
21728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21729       };
21730     } catch (...) {
21731       {
21732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21733       };
21734     }
21735   }
21736
21737 }
21738
21739
21740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21741   void * jresult ;
21742   Dali::TypeRegistry *arg1 = 0 ;
21743   Dali::TypeRegistry *result = 0 ;
21744
21745   arg1 = (Dali::TypeRegistry *)jarg1;
21746   if (!arg1) {
21747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21748     return 0;
21749   }
21750   {
21751     try {
21752       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21753     } catch (std::out_of_range& e) {
21754       {
21755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21756       };
21757     } catch (std::exception& e) {
21758       {
21759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21760       };
21761     } catch (Dali::DaliException e) {
21762       {
21763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21764       };
21765     } catch (...) {
21766       {
21767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21768       };
21769     }
21770   }
21771
21772   jresult = (void *)result;
21773   return jresult;
21774 }
21775
21776
21777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21778   void * jresult ;
21779   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21780   Dali::TypeRegistry *arg2 = 0 ;
21781   Dali::TypeRegistry *result = 0 ;
21782
21783   arg1 = (Dali::TypeRegistry *)jarg1;
21784   arg2 = (Dali::TypeRegistry *)jarg2;
21785   if (!arg2) {
21786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21787     return 0;
21788   }
21789   {
21790     try {
21791       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21792     } catch (std::out_of_range& e) {
21793       {
21794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21795       };
21796     } catch (std::exception& e) {
21797       {
21798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (Dali::DaliException e) {
21801       {
21802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21803       };
21804     } catch (...) {
21805       {
21806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21807       };
21808     }
21809   }
21810
21811   jresult = (void *)result;
21812   return jresult;
21813 }
21814
21815
21816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21817   void * jresult ;
21818   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21819   std::string *arg2 = 0 ;
21820   Dali::TypeInfo result;
21821
21822   arg1 = (Dali::TypeRegistry *)jarg1;
21823   if (!jarg2) {
21824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21825     return 0;
21826   }
21827   std::string arg2_str(jarg2);
21828   arg2 = &arg2_str;
21829   {
21830     try {
21831       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21832     } catch (std::out_of_range& e) {
21833       {
21834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21835       };
21836     } catch (std::exception& e) {
21837       {
21838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21839       };
21840     } catch (Dali::DaliException e) {
21841       {
21842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21843       };
21844     } catch (...) {
21845       {
21846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21847       };
21848     }
21849   }
21850
21851   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21852
21853   //argout typemap for const std::string&
21854
21855   return jresult;
21856 }
21857
21858
21859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21860   void * jresult ;
21861   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21862   std::type_info *arg2 = 0 ;
21863   Dali::TypeInfo result;
21864
21865   arg1 = (Dali::TypeRegistry *)jarg1;
21866   arg2 = (std::type_info *)jarg2;
21867   if (!arg2) {
21868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21869     return 0;
21870   }
21871   {
21872     try {
21873       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21874     } catch (std::out_of_range& e) {
21875       {
21876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21877       };
21878     } catch (std::exception& e) {
21879       {
21880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21881       };
21882     } catch (Dali::DaliException e) {
21883       {
21884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21885       };
21886     } catch (...) {
21887       {
21888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21889       };
21890     }
21891   }
21892
21893   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21894   return jresult;
21895 }
21896
21897
21898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21899   unsigned long jresult ;
21900   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21901   size_t result;
21902
21903   arg1 = (Dali::TypeRegistry *)jarg1;
21904   {
21905     try {
21906       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21907     } catch (std::out_of_range& e) {
21908       {
21909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (std::exception& e) {
21912       {
21913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (Dali::DaliException e) {
21916       {
21917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21918       };
21919     } catch (...) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21922       };
21923     }
21924   }
21925
21926   jresult = (unsigned long)result;
21927   return jresult;
21928 }
21929
21930
21931 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21932   char * jresult ;
21933   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21934   size_t arg2 ;
21935   std::string result;
21936
21937   arg1 = (Dali::TypeRegistry *)jarg1;
21938   arg2 = (size_t)jarg2;
21939   {
21940     try {
21941       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21942     } catch (std::out_of_range& e) {
21943       {
21944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21945       };
21946     } catch (std::exception& e) {
21947       {
21948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21949       };
21950     } catch (Dali::DaliException e) {
21951       {
21952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21953       };
21954     } catch (...) {
21955       {
21956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21957       };
21958     }
21959   }
21960
21961   jresult = SWIG_csharp_string_callback((&result)->c_str());
21962   return jresult;
21963 }
21964
21965
21966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21967   void * jresult ;
21968   std::type_info *arg1 = 0 ;
21969   std::type_info *arg2 = 0 ;
21970   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21971   Dali::TypeRegistration *result = 0 ;
21972
21973   arg1 = (std::type_info *)jarg1;
21974   if (!arg1) {
21975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21976     return 0;
21977   }
21978   arg2 = (std::type_info *)jarg2;
21979   if (!arg2) {
21980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21981     return 0;
21982   }
21983   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21984   {
21985     try {
21986       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21987     } catch (std::out_of_range& e) {
21988       {
21989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21990       };
21991     } catch (std::exception& e) {
21992       {
21993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21994       };
21995     } catch (Dali::DaliException e) {
21996       {
21997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21998       };
21999     } catch (...) {
22000       {
22001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22002       };
22003     }
22004   }
22005
22006   jresult = (void *)result;
22007   return jresult;
22008 }
22009
22010
22011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22012   void * jresult ;
22013   std::type_info *arg1 = 0 ;
22014   std::type_info *arg2 = 0 ;
22015   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22016   bool arg4 ;
22017   Dali::TypeRegistration *result = 0 ;
22018
22019   arg1 = (std::type_info *)jarg1;
22020   if (!arg1) {
22021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22022     return 0;
22023   }
22024   arg2 = (std::type_info *)jarg2;
22025   if (!arg2) {
22026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22027     return 0;
22028   }
22029   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22030   arg4 = jarg4 ? true : false;
22031   {
22032     try {
22033       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22034     } catch (std::out_of_range& e) {
22035       {
22036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22037       };
22038     } catch (std::exception& e) {
22039       {
22040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22041       };
22042     } catch (Dali::DaliException e) {
22043       {
22044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22045       };
22046     } catch (...) {
22047       {
22048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22049       };
22050     }
22051   }
22052
22053   jresult = (void *)result;
22054   return jresult;
22055 }
22056
22057
22058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22059   void * jresult ;
22060   std::string *arg1 = 0 ;
22061   std::type_info *arg2 = 0 ;
22062   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22063   Dali::TypeRegistration *result = 0 ;
22064
22065   if (!jarg1) {
22066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22067     return 0;
22068   }
22069   std::string arg1_str(jarg1);
22070   arg1 = &arg1_str;
22071   arg2 = (std::type_info *)jarg2;
22072   if (!arg2) {
22073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22074     return 0;
22075   }
22076   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22077   {
22078     try {
22079       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22080     } catch (std::out_of_range& e) {
22081       {
22082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22083       };
22084     } catch (std::exception& e) {
22085       {
22086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22087       };
22088     } catch (Dali::DaliException e) {
22089       {
22090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22091       };
22092     } catch (...) {
22093       {
22094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22095       };
22096     }
22097   }
22098
22099   jresult = (void *)result;
22100
22101   //argout typemap for const std::string&
22102
22103   return jresult;
22104 }
22105
22106
22107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22108   char * jresult ;
22109   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22110   std::string result;
22111
22112   arg1 = (Dali::TypeRegistration *)jarg1;
22113   {
22114     try {
22115       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22116     } catch (std::out_of_range& e) {
22117       {
22118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22119       };
22120     } catch (std::exception& e) {
22121       {
22122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22123       };
22124     } catch (Dali::DaliException e) {
22125       {
22126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22127       };
22128     } catch (...) {
22129       {
22130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22131       };
22132     }
22133   }
22134
22135   jresult = SWIG_csharp_string_callback((&result)->c_str());
22136   return jresult;
22137 }
22138
22139
22140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22141   std::string *arg1 = 0 ;
22142   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22143
22144   if (!jarg1) {
22145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22146     return ;
22147   }
22148   std::string arg1_str(jarg1);
22149   arg1 = &arg1_str;
22150   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22151   {
22152     try {
22153       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22154     } catch (std::out_of_range& e) {
22155       {
22156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22157       };
22158     } catch (std::exception& e) {
22159       {
22160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22161       };
22162     } catch (Dali::DaliException e) {
22163       {
22164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22165       };
22166     } catch (...) {
22167       {
22168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22169       };
22170     }
22171   }
22172
22173
22174   //argout typemap for const std::string&
22175
22176 }
22177
22178
22179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22180   std::string *arg1 = 0 ;
22181   std::string *arg2 = 0 ;
22182   int arg3 ;
22183   Dali::Property::Type arg4 ;
22184   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22185   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22186
22187   if (!jarg1) {
22188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22189     return ;
22190   }
22191   std::string arg1_str(jarg1);
22192   arg1 = &arg1_str;
22193   if (!jarg2) {
22194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22195     return ;
22196   }
22197   std::string arg2_str(jarg2);
22198   arg2 = &arg2_str;
22199   arg3 = (int)jarg3;
22200   arg4 = (Dali::Property::Type)jarg4;
22201   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22202   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22203   {
22204     try {
22205       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22206     } catch (std::out_of_range& e) {
22207       {
22208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22209       };
22210     } catch (std::exception& e) {
22211       {
22212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22213       };
22214     } catch (Dali::DaliException e) {
22215       {
22216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22217       };
22218     } catch (...) {
22219       {
22220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22221       };
22222     }
22223   }
22224
22225
22226   //argout typemap for const std::string&
22227
22228
22229   //argout typemap for const std::string&
22230
22231 }
22232
22233
22234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22235   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22236
22237   arg1 = (Dali::TypeRegistration *)jarg1;
22238   {
22239     try {
22240       delete arg1;
22241     } catch (std::out_of_range& e) {
22242       {
22243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22244       };
22245     } catch (std::exception& e) {
22246       {
22247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22248       };
22249     } catch (Dali::DaliException e) {
22250       {
22251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22252       };
22253     } catch (...) {
22254       {
22255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22256       };
22257     }
22258   }
22259
22260 }
22261
22262
22263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22264   void * jresult ;
22265   Dali::TypeRegistration *arg1 = 0 ;
22266   std::string *arg2 = 0 ;
22267   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22268   Dali::SignalConnectorType *result = 0 ;
22269
22270   arg1 = (Dali::TypeRegistration *)jarg1;
22271   if (!arg1) {
22272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22273     return 0;
22274   }
22275   if (!jarg2) {
22276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22277     return 0;
22278   }
22279   std::string arg2_str(jarg2);
22280   arg2 = &arg2_str;
22281   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22282   {
22283     try {
22284       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22285     } catch (std::out_of_range& e) {
22286       {
22287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22288       };
22289     } catch (std::exception& e) {
22290       {
22291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22292       };
22293     } catch (Dali::DaliException e) {
22294       {
22295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22296       };
22297     } catch (...) {
22298       {
22299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22300       };
22301     }
22302   }
22303
22304   jresult = (void *)result;
22305
22306   //argout typemap for const std::string&
22307
22308   return jresult;
22309 }
22310
22311
22312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22313   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22314
22315   arg1 = (Dali::SignalConnectorType *)jarg1;
22316   {
22317     try {
22318       delete arg1;
22319     } catch (std::out_of_range& e) {
22320       {
22321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22322       };
22323     } catch (std::exception& e) {
22324       {
22325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22326       };
22327     } catch (Dali::DaliException e) {
22328       {
22329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22330       };
22331     } catch (...) {
22332       {
22333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22334       };
22335     }
22336   }
22337
22338 }
22339
22340
22341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22342   void * jresult ;
22343   Dali::TypeRegistration *arg1 = 0 ;
22344   std::string *arg2 = 0 ;
22345   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22346   Dali::TypeAction *result = 0 ;
22347
22348   arg1 = (Dali::TypeRegistration *)jarg1;
22349   if (!arg1) {
22350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22351     return 0;
22352   }
22353   if (!jarg2) {
22354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22355     return 0;
22356   }
22357   std::string arg2_str(jarg2);
22358   arg2 = &arg2_str;
22359   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22360   {
22361     try {
22362       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22363     } catch (std::out_of_range& e) {
22364       {
22365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22366       };
22367     } catch (std::exception& e) {
22368       {
22369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22370       };
22371     } catch (Dali::DaliException e) {
22372       {
22373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22374       };
22375     } catch (...) {
22376       {
22377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22378       };
22379     }
22380   }
22381
22382   jresult = (void *)result;
22383
22384   //argout typemap for const std::string&
22385
22386   return jresult;
22387 }
22388
22389
22390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22391   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22392
22393   arg1 = (Dali::TypeAction *)jarg1;
22394   {
22395     try {
22396       delete arg1;
22397     } catch (std::out_of_range& e) {
22398       {
22399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22400       };
22401     } catch (std::exception& e) {
22402       {
22403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22404       };
22405     } catch (Dali::DaliException e) {
22406       {
22407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22408       };
22409     } catch (...) {
22410       {
22411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22412       };
22413     }
22414   }
22415
22416 }
22417
22418
22419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22420   void * jresult ;
22421   Dali::TypeRegistration *arg1 = 0 ;
22422   std::string *arg2 = 0 ;
22423   Dali::Property::Index arg3 ;
22424   Dali::Property::Type arg4 ;
22425   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22426   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22427   Dali::PropertyRegistration *result = 0 ;
22428
22429   arg1 = (Dali::TypeRegistration *)jarg1;
22430   if (!arg1) {
22431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22432     return 0;
22433   }
22434   if (!jarg2) {
22435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22436     return 0;
22437   }
22438   std::string arg2_str(jarg2);
22439   arg2 = &arg2_str;
22440   arg3 = (Dali::Property::Index)jarg3;
22441   arg4 = (Dali::Property::Type)jarg4;
22442   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22443   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22444   {
22445     try {
22446       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22447     } catch (std::out_of_range& e) {
22448       {
22449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22450       };
22451     } catch (std::exception& e) {
22452       {
22453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22454       };
22455     } catch (Dali::DaliException e) {
22456       {
22457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22458       };
22459     } catch (...) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22462       };
22463     }
22464   }
22465
22466   jresult = (void *)result;
22467
22468   //argout typemap for const std::string&
22469
22470   return jresult;
22471 }
22472
22473
22474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22475   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22476
22477   arg1 = (Dali::PropertyRegistration *)jarg1;
22478   {
22479     try {
22480       delete arg1;
22481     } catch (std::out_of_range& e) {
22482       {
22483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22484       };
22485     } catch (std::exception& e) {
22486       {
22487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22488       };
22489     } catch (Dali::DaliException e) {
22490       {
22491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22492       };
22493     } catch (...) {
22494       {
22495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22496       };
22497     }
22498   }
22499
22500 }
22501
22502
22503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22504   void * jresult ;
22505   Dali::TypeRegistration *arg1 = 0 ;
22506   std::string *arg2 = 0 ;
22507   Dali::Property::Index arg3 ;
22508   Dali::Property::Type arg4 ;
22509   Dali::AnimatablePropertyRegistration *result = 0 ;
22510
22511   arg1 = (Dali::TypeRegistration *)jarg1;
22512   if (!arg1) {
22513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22514     return 0;
22515   }
22516   if (!jarg2) {
22517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22518     return 0;
22519   }
22520   std::string arg2_str(jarg2);
22521   arg2 = &arg2_str;
22522   arg3 = (Dali::Property::Index)jarg3;
22523   arg4 = (Dali::Property::Type)jarg4;
22524   {
22525     try {
22526       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22527     } catch (std::out_of_range& e) {
22528       {
22529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22530       };
22531     } catch (std::exception& e) {
22532       {
22533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22534       };
22535     } catch (Dali::DaliException e) {
22536       {
22537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22538       };
22539     } catch (...) {
22540       {
22541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22542       };
22543     }
22544   }
22545
22546   jresult = (void *)result;
22547
22548   //argout typemap for const std::string&
22549
22550   return jresult;
22551 }
22552
22553
22554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22555   void * jresult ;
22556   Dali::TypeRegistration *arg1 = 0 ;
22557   std::string *arg2 = 0 ;
22558   Dali::Property::Index arg3 ;
22559   Dali::Property::Value *arg4 = 0 ;
22560   Dali::AnimatablePropertyRegistration *result = 0 ;
22561
22562   arg1 = (Dali::TypeRegistration *)jarg1;
22563   if (!arg1) {
22564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22565     return 0;
22566   }
22567   if (!jarg2) {
22568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22569     return 0;
22570   }
22571   std::string arg2_str(jarg2);
22572   arg2 = &arg2_str;
22573   arg3 = (Dali::Property::Index)jarg3;
22574   arg4 = (Dali::Property::Value *)jarg4;
22575   if (!arg4) {
22576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22577     return 0;
22578   }
22579   {
22580     try {
22581       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22582     } catch (std::out_of_range& e) {
22583       {
22584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22585       };
22586     } catch (std::exception& e) {
22587       {
22588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22589       };
22590     } catch (Dali::DaliException e) {
22591       {
22592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22593       };
22594     } catch (...) {
22595       {
22596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22597       };
22598     }
22599   }
22600
22601   jresult = (void *)result;
22602
22603   //argout typemap for const std::string&
22604
22605   return jresult;
22606 }
22607
22608
22609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22610   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22611
22612   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22613   {
22614     try {
22615       delete arg1;
22616     } catch (std::out_of_range& e) {
22617       {
22618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22619       };
22620     } catch (std::exception& e) {
22621       {
22622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22623       };
22624     } catch (Dali::DaliException e) {
22625       {
22626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22627       };
22628     } catch (...) {
22629       {
22630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22631       };
22632     }
22633   }
22634
22635 }
22636
22637
22638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22639   void * jresult ;
22640   Dali::TypeRegistration *arg1 = 0 ;
22641   std::string *arg2 = 0 ;
22642   Dali::Property::Index arg3 ;
22643   Dali::Property::Index arg4 ;
22644   unsigned int arg5 ;
22645   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22646
22647   arg1 = (Dali::TypeRegistration *)jarg1;
22648   if (!arg1) {
22649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22650     return 0;
22651   }
22652   if (!jarg2) {
22653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22654     return 0;
22655   }
22656   std::string arg2_str(jarg2);
22657   arg2 = &arg2_str;
22658   arg3 = (Dali::Property::Index)jarg3;
22659   arg4 = (Dali::Property::Index)jarg4;
22660   arg5 = (unsigned int)jarg5;
22661   {
22662     try {
22663       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22664     } catch (std::out_of_range& e) {
22665       {
22666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22667       };
22668     } catch (std::exception& e) {
22669       {
22670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22671       };
22672     } catch (Dali::DaliException e) {
22673       {
22674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22675       };
22676     } catch (...) {
22677       {
22678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22679       };
22680     }
22681   }
22682
22683   jresult = (void *)result;
22684
22685   //argout typemap for const std::string&
22686
22687   return jresult;
22688 }
22689
22690
22691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22692   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22693
22694   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22695   {
22696     try {
22697       delete arg1;
22698     } catch (std::out_of_range& e) {
22699       {
22700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22701       };
22702     } catch (std::exception& e) {
22703       {
22704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22705       };
22706     } catch (Dali::DaliException e) {
22707       {
22708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22709       };
22710     } catch (...) {
22711       {
22712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22713       };
22714     }
22715   }
22716
22717 }
22718
22719
22720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22721   void * jresult ;
22722   Dali::TypeRegistration *arg1 = 0 ;
22723   std::string *arg2 = 0 ;
22724   Dali::Property::Index arg3 ;
22725   Dali::Property::Type arg4 ;
22726   Dali::ChildPropertyRegistration *result = 0 ;
22727
22728   arg1 = (Dali::TypeRegistration *)jarg1;
22729   if (!arg1) {
22730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22731     return 0;
22732   }
22733   if (!jarg2) {
22734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22735     return 0;
22736   }
22737   std::string arg2_str(jarg2);
22738   arg2 = &arg2_str;
22739   arg3 = (Dali::Property::Index)jarg3;
22740   arg4 = (Dali::Property::Type)jarg4;
22741   {
22742     try {
22743       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22744     } catch (std::out_of_range& e) {
22745       {
22746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22747       };
22748     } catch (std::exception& e) {
22749       {
22750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22751       };
22752     } catch (Dali::DaliException e) {
22753       {
22754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22755       };
22756     } catch (...) {
22757       {
22758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22759       };
22760     }
22761   }
22762
22763   jresult = (void *)result;
22764
22765   //argout typemap for const std::string&
22766
22767   return jresult;
22768 }
22769
22770
22771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22772   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22773
22774   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22775   {
22776     try {
22777       delete arg1;
22778     } catch (std::out_of_range& e) {
22779       {
22780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22781       };
22782     } catch (std::exception& e) {
22783       {
22784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22785       };
22786     } catch (Dali::DaliException e) {
22787       {
22788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22789       };
22790     } catch (...) {
22791       {
22792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22793       };
22794     }
22795   }
22796
22797 }
22798
22799
22800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22801   unsigned int jresult ;
22802   std::string *arg1 = 0 ;
22803   std::type_info *arg2 = 0 ;
22804   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22805   bool result;
22806
22807   if (!jarg1) {
22808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22809     return 0;
22810   }
22811   std::string arg1_str(jarg1);
22812   arg1 = &arg1_str;
22813   arg2 = (std::type_info *)jarg2;
22814   if (!arg2) {
22815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22816     return 0;
22817   }
22818   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22819   {
22820     try {
22821       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22822     } catch (std::out_of_range& e) {
22823       {
22824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22825       };
22826     } catch (std::exception& e) {
22827       {
22828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22829       };
22830     } catch (Dali::DaliException e) {
22831       {
22832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22833       };
22834     } catch (...) {
22835       {
22836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22837       };
22838     }
22839   }
22840
22841   jresult = result;
22842
22843   //argout typemap for const std::string&
22844
22845   return jresult;
22846 }
22847
22848
22849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22850   unsigned int jresult ;
22851   std::string *arg1 = 0 ;
22852   std::string *arg2 = 0 ;
22853   Dali::Property::Index arg3 ;
22854   Dali::Property::Type arg4 ;
22855   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22856   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22857   bool result;
22858
22859   if (!jarg1) {
22860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22861     return 0;
22862   }
22863   std::string arg1_str(jarg1);
22864   arg1 = &arg1_str;
22865   if (!jarg2) {
22866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22867     return 0;
22868   }
22869   std::string arg2_str(jarg2);
22870   arg2 = &arg2_str;
22871   arg3 = (Dali::Property::Index)jarg3;
22872   arg4 = (Dali::Property::Type)jarg4;
22873   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22874   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22875   {
22876     try {
22877       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22878     } catch (std::out_of_range& e) {
22879       {
22880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22881       };
22882     } catch (std::exception& e) {
22883       {
22884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22885       };
22886     } catch (Dali::DaliException e) {
22887       {
22888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22889       };
22890     } catch (...) {
22891       {
22892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22893       };
22894     }
22895   }
22896
22897   jresult = result;
22898
22899   //argout typemap for const std::string&
22900
22901
22902   //argout typemap for const std::string&
22903
22904   return jresult;
22905 }
22906
22907
22908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22909   float jresult ;
22910   float result;
22911
22912   result = (float)(float)Dali::ParentOrigin::TOP;
22913   jresult = result;
22914   return jresult;
22915 }
22916
22917
22918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22919   float jresult ;
22920   float result;
22921
22922   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22923   jresult = result;
22924   return jresult;
22925 }
22926
22927
22928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22929   float jresult ;
22930   float result;
22931
22932   result = (float)(float)Dali::ParentOrigin::LEFT;
22933   jresult = result;
22934   return jresult;
22935 }
22936
22937
22938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22939   float jresult ;
22940   float result;
22941
22942   result = (float)(float)Dali::ParentOrigin::RIGHT;
22943   jresult = result;
22944   return jresult;
22945 }
22946
22947
22948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22949   float jresult ;
22950   float result;
22951
22952   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22953   jresult = result;
22954   return jresult;
22955 }
22956
22957
22958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22959   void * jresult ;
22960   Dali::Vector3 *result = 0 ;
22961
22962   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22963   jresult = (void *)result;
22964   return jresult;
22965 }
22966
22967
22968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22969   void * jresult ;
22970   Dali::Vector3 *result = 0 ;
22971
22972   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22973   jresult = (void *)result;
22974   return jresult;
22975 }
22976
22977
22978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22979   void * jresult ;
22980   Dali::Vector3 *result = 0 ;
22981
22982   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22983   jresult = (void *)result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22989   void * jresult ;
22990   Dali::Vector3 *result = 0 ;
22991
22992   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22993   jresult = (void *)result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22999   void * jresult ;
23000   Dali::Vector3 *result = 0 ;
23001
23002   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23003   jresult = (void *)result;
23004   return jresult;
23005 }
23006
23007
23008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23009   void * jresult ;
23010   Dali::Vector3 *result = 0 ;
23011
23012   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23013   jresult = (void *)result;
23014   return jresult;
23015 }
23016
23017
23018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23019   void * jresult ;
23020   Dali::Vector3 *result = 0 ;
23021
23022   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23029   void * jresult ;
23030   Dali::Vector3 *result = 0 ;
23031
23032   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23033   jresult = (void *)result;
23034   return jresult;
23035 }
23036
23037
23038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23039   void * jresult ;
23040   Dali::Vector3 *result = 0 ;
23041
23042   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23043   jresult = (void *)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23049   float jresult ;
23050   float result;
23051
23052   result = (float)(float)Dali::AnchorPoint::TOP;
23053   jresult = result;
23054   return jresult;
23055 }
23056
23057
23058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23059   float jresult ;
23060   float result;
23061
23062   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23063   jresult = result;
23064   return jresult;
23065 }
23066
23067
23068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23069   float jresult ;
23070   float result;
23071
23072   result = (float)(float)Dali::AnchorPoint::LEFT;
23073   jresult = result;
23074   return jresult;
23075 }
23076
23077
23078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23079   float jresult ;
23080   float result;
23081
23082   result = (float)(float)Dali::AnchorPoint::RIGHT;
23083   jresult = result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23089   float jresult ;
23090   float result;
23091
23092   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23093   jresult = result;
23094   return jresult;
23095 }
23096
23097
23098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23099   void * jresult ;
23100   Dali::Vector3 *result = 0 ;
23101
23102   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23103   jresult = (void *)result;
23104   return jresult;
23105 }
23106
23107
23108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23109   void * jresult ;
23110   Dali::Vector3 *result = 0 ;
23111
23112   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23113   jresult = (void *)result;
23114   return jresult;
23115 }
23116
23117
23118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23119   void * jresult ;
23120   Dali::Vector3 *result = 0 ;
23121
23122   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23123   jresult = (void *)result;
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23129   void * jresult ;
23130   Dali::Vector3 *result = 0 ;
23131
23132   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23133   jresult = (void *)result;
23134   return jresult;
23135 }
23136
23137
23138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23139   void * jresult ;
23140   Dali::Vector3 *result = 0 ;
23141
23142   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23143   jresult = (void *)result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23149   void * jresult ;
23150   Dali::Vector3 *result = 0 ;
23151
23152   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23153   jresult = (void *)result;
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23159   void * jresult ;
23160   Dali::Vector3 *result = 0 ;
23161
23162   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23163   jresult = (void *)result;
23164   return jresult;
23165 }
23166
23167
23168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23169   void * jresult ;
23170   Dali::Vector3 *result = 0 ;
23171
23172   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23173   jresult = (void *)result;
23174   return jresult;
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23179   void * jresult ;
23180   Dali::Vector3 *result = 0 ;
23181
23182   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23183   jresult = (void *)result;
23184   return jresult;
23185 }
23186
23187
23188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23189   void * jresult ;
23190   Dali::Vector4 *result = 0 ;
23191
23192   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23193   jresult = (void *)result;
23194   return jresult;
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23199   void * jresult ;
23200   Dali::Vector4 *result = 0 ;
23201
23202   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23203   jresult = (void *)result;
23204   return jresult;
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23209   void * jresult ;
23210   Dali::Vector4 *result = 0 ;
23211
23212   result = (Dali::Vector4 *)&Dali::Color::RED;
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23219   void * jresult ;
23220   Dali::Vector4 *result = 0 ;
23221
23222   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23223   jresult = (void *)result;
23224   return jresult;
23225 }
23226
23227
23228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23229   void * jresult ;
23230   Dali::Vector4 *result = 0 ;
23231
23232   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23233   jresult = (void *)result;
23234   return jresult;
23235 }
23236
23237
23238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23239   void * jresult ;
23240   Dali::Vector4 *result = 0 ;
23241
23242   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23249   void * jresult ;
23250   Dali::Vector4 *result = 0 ;
23251
23252   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23253   jresult = (void *)result;
23254   return jresult;
23255 }
23256
23257
23258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23259   void * jresult ;
23260   Dali::Vector4 *result = 0 ;
23261
23262   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23269   void * jresult ;
23270   Dali::Vector4 *result = 0 ;
23271
23272   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23279   float jresult ;
23280   float result;
23281
23282   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23283   jresult = result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23289   float jresult ;
23290   float result;
23291
23292   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23293   jresult = result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23299   float jresult ;
23300   float result;
23301
23302   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23303   jresult = result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23309   float jresult ;
23310   float result;
23311
23312   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23313   jresult = result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23319   float jresult ;
23320   float result;
23321
23322   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23323   jresult = result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23329   float jresult ;
23330   float result;
23331
23332   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23333   jresult = result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23339   float jresult ;
23340   float result;
23341
23342   result = (float)(float)Dali::Math::PI;
23343   jresult = result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23349   float jresult ;
23350   float result;
23351
23352   result = (float)(float)Dali::Math::PI_2;
23353   jresult = result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23359   float jresult ;
23360   float result;
23361
23362   result = (float)(float)Dali::Math::PI_4;
23363   jresult = result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23369   float jresult ;
23370   float result;
23371
23372   result = (float)(float)Dali::Math::PI_OVER_180;
23373   jresult = result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23379   float jresult ;
23380   float result;
23381
23382   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23383   jresult = result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23389   int jresult ;
23390   Dali::ResizePolicy::Type result;
23391
23392   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23399   unsigned long jresult ;
23400   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23401   Dali::VectorBase::SizeType result;
23402
23403   arg1 = (Dali::VectorBase *)jarg1;
23404   {
23405     try {
23406       result = ((Dali::VectorBase const *)arg1)->Count();
23407     } catch (std::out_of_range& e) {
23408       {
23409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23410       };
23411     } catch (std::exception& e) {
23412       {
23413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23414       };
23415     } catch (Dali::DaliException e) {
23416       {
23417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23418       };
23419     } catch (...) {
23420       {
23421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23422       };
23423     }
23424   }
23425
23426   jresult = (unsigned long)result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23432   unsigned long jresult ;
23433   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23434   Dali::VectorBase::SizeType result;
23435
23436   arg1 = (Dali::VectorBase *)jarg1;
23437   {
23438     try {
23439       result = ((Dali::VectorBase const *)arg1)->Size();
23440     } catch (std::out_of_range& e) {
23441       {
23442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23443       };
23444     } catch (std::exception& e) {
23445       {
23446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23447       };
23448     } catch (Dali::DaliException e) {
23449       {
23450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23451       };
23452     } catch (...) {
23453       {
23454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23455       };
23456     }
23457   }
23458
23459   jresult = (unsigned long)result;
23460   return jresult;
23461 }
23462
23463
23464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23465   unsigned int jresult ;
23466   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23467   bool result;
23468
23469   arg1 = (Dali::VectorBase *)jarg1;
23470   {
23471     try {
23472       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23473     } catch (std::out_of_range& e) {
23474       {
23475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23476       };
23477     } catch (std::exception& e) {
23478       {
23479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23480       };
23481     } catch (Dali::DaliException e) {
23482       {
23483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23484       };
23485     } catch (...) {
23486       {
23487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23488       };
23489     }
23490   }
23491
23492   jresult = result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23498   unsigned long jresult ;
23499   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23500   Dali::VectorBase::SizeType result;
23501
23502   arg1 = (Dali::VectorBase *)jarg1;
23503   {
23504     try {
23505       result = ((Dali::VectorBase const *)arg1)->Capacity();
23506     } catch (std::out_of_range& e) {
23507       {
23508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23509       };
23510     } catch (std::exception& e) {
23511       {
23512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23513       };
23514     } catch (Dali::DaliException e) {
23515       {
23516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23517       };
23518     } catch (...) {
23519       {
23520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23521       };
23522     }
23523   }
23524
23525   jresult = (unsigned long)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23531   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23532
23533   arg1 = (Dali::VectorBase *)jarg1;
23534   {
23535     try {
23536       (arg1)->Release();
23537     } catch (std::out_of_range& e) {
23538       {
23539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23540       };
23541     } catch (std::exception& e) {
23542       {
23543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23544       };
23545     } catch (Dali::DaliException e) {
23546       {
23547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23548       };
23549     } catch (...) {
23550       {
23551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23552       };
23553     }
23554   }
23555
23556 }
23557
23558
23559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23560   void * jresult ;
23561   Dali::Image *result = 0 ;
23562
23563   {
23564     try {
23565       result = (Dali::Image *)new Dali::Image();
23566     } catch (std::out_of_range& e) {
23567       {
23568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23569       };
23570     } catch (std::exception& e) {
23571       {
23572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23573       };
23574     } catch (Dali::DaliException e) {
23575       {
23576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23577       };
23578     } catch (...) {
23579       {
23580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23581       };
23582     }
23583   }
23584
23585   jresult = (void *)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23591   Dali::Image *arg1 = (Dali::Image *) 0 ;
23592
23593   arg1 = (Dali::Image *)jarg1;
23594   {
23595     try {
23596       delete arg1;
23597     } catch (std::out_of_range& e) {
23598       {
23599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23600       };
23601     } catch (std::exception& e) {
23602       {
23603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23604       };
23605     } catch (Dali::DaliException e) {
23606       {
23607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23608       };
23609     } catch (...) {
23610       {
23611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23612       };
23613     }
23614   }
23615
23616 }
23617
23618
23619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23620   void * jresult ;
23621   Dali::Image *arg1 = 0 ;
23622   Dali::Image *result = 0 ;
23623
23624   arg1 = (Dali::Image *)jarg1;
23625   if (!arg1) {
23626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23627     return 0;
23628   }
23629   {
23630     try {
23631       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23632     } catch (std::out_of_range& e) {
23633       {
23634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (std::exception& e) {
23637       {
23638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (Dali::DaliException e) {
23641       {
23642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23643       };
23644     } catch (...) {
23645       {
23646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23647       };
23648     }
23649   }
23650
23651   jresult = (void *)result;
23652   return jresult;
23653 }
23654
23655
23656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23657   void * jresult ;
23658   Dali::Image *arg1 = (Dali::Image *) 0 ;
23659   Dali::Image *arg2 = 0 ;
23660   Dali::Image *result = 0 ;
23661
23662   arg1 = (Dali::Image *)jarg1;
23663   arg2 = (Dali::Image *)jarg2;
23664   if (!arg2) {
23665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23666     return 0;
23667   }
23668   {
23669     try {
23670       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23671     } catch (std::out_of_range& e) {
23672       {
23673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23674       };
23675     } catch (std::exception& e) {
23676       {
23677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (Dali::DaliException e) {
23680       {
23681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23682       };
23683     } catch (...) {
23684       {
23685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23686       };
23687     }
23688   }
23689
23690   jresult = (void *)result;
23691   return jresult;
23692 }
23693
23694
23695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23696   void * jresult ;
23697   Dali::BaseHandle arg1 ;
23698   Dali::BaseHandle *argp1 ;
23699   Dali::Image result;
23700
23701   argp1 = (Dali::BaseHandle *)jarg1;
23702   if (!argp1) {
23703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23704     return 0;
23705   }
23706   arg1 = *argp1;
23707   {
23708     try {
23709       result = Dali::Image::DownCast(arg1);
23710     } catch (std::out_of_range& e) {
23711       {
23712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23713       };
23714     } catch (std::exception& e) {
23715       {
23716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23717       };
23718     } catch (Dali::DaliException e) {
23719       {
23720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23721       };
23722     } catch (...) {
23723       {
23724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23725       };
23726     }
23727   }
23728
23729   jresult = new Dali::Image((const Dali::Image &)result);
23730   return jresult;
23731 }
23732
23733
23734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23735   unsigned int jresult ;
23736   Dali::Image *arg1 = (Dali::Image *) 0 ;
23737   unsigned int result;
23738
23739   arg1 = (Dali::Image *)jarg1;
23740   {
23741     try {
23742       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23743     } catch (std::out_of_range& e) {
23744       {
23745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23746       };
23747     } catch (std::exception& e) {
23748       {
23749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23750       };
23751     } catch (Dali::DaliException e) {
23752       {
23753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23754       };
23755     } catch (...) {
23756       {
23757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23758       };
23759     }
23760   }
23761
23762   jresult = result;
23763   return jresult;
23764 }
23765
23766
23767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23768   unsigned int jresult ;
23769   Dali::Image *arg1 = (Dali::Image *) 0 ;
23770   unsigned int result;
23771
23772   arg1 = (Dali::Image *)jarg1;
23773   {
23774     try {
23775       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23776     } catch (std::out_of_range& e) {
23777       {
23778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23779       };
23780     } catch (std::exception& e) {
23781       {
23782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23783       };
23784     } catch (Dali::DaliException e) {
23785       {
23786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23787       };
23788     } catch (...) {
23789       {
23790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23791       };
23792     }
23793   }
23794
23795   jresult = result;
23796   return jresult;
23797 }
23798
23799
23800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23801   void * jresult ;
23802   Dali::Image *arg1 = (Dali::Image *) 0 ;
23803   Dali::Image::ImageSignalType *result = 0 ;
23804
23805   arg1 = (Dali::Image *)jarg1;
23806   {
23807     try {
23808       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23809     } catch (std::out_of_range& e) {
23810       {
23811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23812       };
23813     } catch (std::exception& e) {
23814       {
23815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23816       };
23817     } catch (Dali::DaliException e) {
23818       {
23819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23820       };
23821     } catch (...) {
23822       {
23823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23824       };
23825     }
23826   }
23827
23828   jresult = (void *)result;
23829   return jresult;
23830 }
23831
23832
23833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23834   int jresult ;
23835   Dali::Pixel::Format result;
23836
23837   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23838   jresult = (int)result;
23839   return jresult;
23840 }
23841
23842
23843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23844   int jresult ;
23845   Dali::Pixel::Format result;
23846
23847   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23848   jresult = (int)result;
23849   return jresult;
23850 }
23851
23852
23853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23854   unsigned int jresult ;
23855   Dali::Pixel::Format arg1 ;
23856   bool result;
23857
23858   arg1 = (Dali::Pixel::Format)jarg1;
23859   {
23860     try {
23861       result = (bool)Dali::Pixel::HasAlpha(arg1);
23862     } catch (std::out_of_range& e) {
23863       {
23864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23865       };
23866     } catch (std::exception& e) {
23867       {
23868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23869       };
23870     } catch (Dali::DaliException e) {
23871       {
23872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23873       };
23874     } catch (...) {
23875       {
23876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23877       };
23878     }
23879   }
23880
23881   jresult = result;
23882   return jresult;
23883 }
23884
23885
23886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23887   unsigned int jresult ;
23888   Dali::Pixel::Format arg1 ;
23889   unsigned int result;
23890
23891   arg1 = (Dali::Pixel::Format)jarg1;
23892   {
23893     try {
23894       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23895     } catch (std::out_of_range& e) {
23896       {
23897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23898       };
23899     } catch (std::exception& e) {
23900       {
23901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (Dali::DaliException e) {
23904       {
23905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23906       };
23907     } catch (...) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23910       };
23911     }
23912   }
23913
23914   jresult = result;
23915   return jresult;
23916 }
23917
23918
23919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23920   Dali::Pixel::Format arg1 ;
23921   int *arg2 = 0 ;
23922   int *arg3 = 0 ;
23923
23924   arg1 = (Dali::Pixel::Format)jarg1;
23925   arg2 = (int *)jarg2;
23926   if (!arg2) {
23927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23928     return ;
23929   }
23930   arg3 = (int *)jarg3;
23931   if (!arg3) {
23932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23933     return ;
23934   }
23935   {
23936     try {
23937       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23938     } catch (std::out_of_range& e) {
23939       {
23940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23941       };
23942     } catch (std::exception& e) {
23943       {
23944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23945       };
23946     } catch (Dali::DaliException e) {
23947       {
23948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23949       };
23950     } catch (...) {
23951       {
23952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23953       };
23954     }
23955   }
23956
23957 }
23958
23959
23960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23961   void * jresult ;
23962   unsigned char *arg1 = (unsigned char *) 0 ;
23963   unsigned int arg2 ;
23964   unsigned int arg3 ;
23965   unsigned int arg4 ;
23966   Dali::Pixel::Format arg5 ;
23967   Dali::PixelData::ReleaseFunction arg6 ;
23968   Dali::PixelData result;
23969
23970   arg1 = jarg1;
23971   arg2 = (unsigned int)jarg2;
23972   arg3 = (unsigned int)jarg3;
23973   arg4 = (unsigned int)jarg4;
23974   arg5 = (Dali::Pixel::Format)jarg5;
23975   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23976   {
23977     try {
23978       auto pixelBuffer = new unsigned char[jarg2];
23979       memcpy( pixelBuffer, arg1, arg2);
23980       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23981     } catch (std::out_of_range& e) {
23982       {
23983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23984       };
23985     } catch (std::exception& e) {
23986       {
23987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23988       };
23989     } catch (Dali::DaliException e) {
23990       {
23991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23992       };
23993     } catch (...) {
23994       {
23995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23996       };
23997     }
23998   }
23999
24000   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24001
24002
24003   return jresult;
24004 }
24005
24006
24007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24008   void * jresult ;
24009   Dali::PixelData *result = 0 ;
24010
24011   {
24012     try {
24013       result = (Dali::PixelData *)new Dali::PixelData();
24014     } catch (std::out_of_range& e) {
24015       {
24016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24017       };
24018     } catch (std::exception& e) {
24019       {
24020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24021       };
24022     } catch (Dali::DaliException e) {
24023       {
24024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24025       };
24026     } catch (...) {
24027       {
24028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24029       };
24030     }
24031   }
24032
24033   jresult = (void *)result;
24034   return jresult;
24035 }
24036
24037
24038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24039   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24040
24041   arg1 = (Dali::PixelData *)jarg1;
24042   {
24043     try {
24044       delete arg1;
24045     } catch (std::out_of_range& e) {
24046       {
24047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24048       };
24049     } catch (std::exception& e) {
24050       {
24051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24052       };
24053     } catch (Dali::DaliException e) {
24054       {
24055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24056       };
24057     } catch (...) {
24058       {
24059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24060       };
24061     }
24062   }
24063
24064 }
24065
24066
24067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24068   void * jresult ;
24069   Dali::PixelData *arg1 = 0 ;
24070   Dali::PixelData *result = 0 ;
24071
24072   arg1 = (Dali::PixelData *)jarg1;
24073   if (!arg1) {
24074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24075     return 0;
24076   }
24077   {
24078     try {
24079       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24080     } catch (std::out_of_range& e) {
24081       {
24082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (std::exception& e) {
24085       {
24086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24087       };
24088     } catch (Dali::DaliException e) {
24089       {
24090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24091       };
24092     } catch (...) {
24093       {
24094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24095       };
24096     }
24097   }
24098
24099   jresult = (void *)result;
24100   return jresult;
24101 }
24102
24103
24104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24105   void * jresult ;
24106   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24107   Dali::PixelData *arg2 = 0 ;
24108   Dali::PixelData *result = 0 ;
24109
24110   arg1 = (Dali::PixelData *)jarg1;
24111   arg2 = (Dali::PixelData *)jarg2;
24112   if (!arg2) {
24113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24114     return 0;
24115   }
24116   {
24117     try {
24118       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24119     } catch (std::out_of_range& e) {
24120       {
24121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24122       };
24123     } catch (std::exception& e) {
24124       {
24125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24126       };
24127     } catch (Dali::DaliException e) {
24128       {
24129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24130       };
24131     } catch (...) {
24132       {
24133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24134       };
24135     }
24136   }
24137
24138   jresult = (void *)result;
24139   return jresult;
24140 }
24141
24142
24143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24144   unsigned int jresult ;
24145   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24146   unsigned int result;
24147
24148   arg1 = (Dali::PixelData *)jarg1;
24149   {
24150     try {
24151       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24152     } catch (std::out_of_range& e) {
24153       {
24154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24155       };
24156     } catch (std::exception& e) {
24157       {
24158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24159       };
24160     } catch (Dali::DaliException e) {
24161       {
24162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24163       };
24164     } catch (...) {
24165       {
24166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24167       };
24168     }
24169   }
24170
24171   jresult = result;
24172   return jresult;
24173 }
24174
24175
24176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24177   unsigned int jresult ;
24178   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24179   unsigned int result;
24180
24181   arg1 = (Dali::PixelData *)jarg1;
24182   {
24183     try {
24184       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24185     } catch (std::out_of_range& e) {
24186       {
24187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (std::exception& e) {
24190       {
24191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24192       };
24193     } catch (Dali::DaliException e) {
24194       {
24195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24196       };
24197     } catch (...) {
24198       {
24199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24200       };
24201     }
24202   }
24203
24204   jresult = result;
24205   return jresult;
24206 }
24207
24208
24209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24210   int jresult ;
24211   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24212   Dali::Pixel::Format result;
24213
24214   arg1 = (Dali::PixelData *)jarg1;
24215   {
24216     try {
24217       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24218     } catch (std::out_of_range& e) {
24219       {
24220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (std::exception& e) {
24223       {
24224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24225       };
24226     } catch (Dali::DaliException e) {
24227       {
24228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24229       };
24230     } catch (...) {
24231       {
24232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24233       };
24234     }
24235   }
24236
24237   jresult = (int)result;
24238   return jresult;
24239 }
24240
24241
24242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24243   unsigned int jresult ;
24244   unsigned int result;
24245
24246   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24247   jresult = result;
24248   return jresult;
24249 }
24250
24251
24252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24253   unsigned int jresult ;
24254   unsigned int result;
24255
24256   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24257   jresult = result;
24258   return jresult;
24259 }
24260
24261
24262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24263   unsigned int jresult ;
24264   unsigned int result;
24265
24266   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24267   jresult = result;
24268   return jresult;
24269 }
24270
24271
24272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24273   unsigned int jresult ;
24274   unsigned int result;
24275
24276   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24277   jresult = result;
24278   return jresult;
24279 }
24280
24281
24282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24283   unsigned int jresult ;
24284   unsigned int result;
24285
24286   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24287   jresult = result;
24288   return jresult;
24289 }
24290
24291
24292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24293   unsigned int jresult ;
24294   unsigned int result;
24295
24296   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24297   jresult = result;
24298   return jresult;
24299 }
24300
24301
24302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24303   void * jresult ;
24304   Dali::TextureType::Type arg1 ;
24305   Dali::Pixel::Format arg2 ;
24306   unsigned int arg3 ;
24307   unsigned int arg4 ;
24308   Dali::Texture result;
24309
24310   arg1 = (Dali::TextureType::Type)jarg1;
24311   arg2 = (Dali::Pixel::Format)jarg2;
24312   arg3 = (unsigned int)jarg3;
24313   arg4 = (unsigned int)jarg4;
24314   {
24315     try {
24316       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24317     } catch (std::out_of_range& e) {
24318       {
24319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24320       };
24321     } catch (std::exception& e) {
24322       {
24323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24324       };
24325     } catch (Dali::DaliException e) {
24326       {
24327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24328       };
24329     } catch (...) {
24330       {
24331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24332       };
24333     }
24334   }
24335
24336   jresult = new Dali::Texture((const Dali::Texture &)result);
24337   return jresult;
24338 }
24339
24340
24341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24342   void * jresult ;
24343   NativeImageInterface *arg1 = 0 ;
24344   Dali::Texture result;
24345
24346   arg1 = (NativeImageInterface *)jarg1;
24347   if (!arg1) {
24348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24349     return 0;
24350   }
24351   {
24352     try {
24353       result = Dali::Texture::New(*arg1);
24354     } catch (std::out_of_range& e) {
24355       {
24356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24357       };
24358     } catch (std::exception& e) {
24359       {
24360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24361       };
24362     } catch (Dali::DaliException e) {
24363       {
24364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24365       };
24366     } catch (...) {
24367       {
24368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24369       };
24370     }
24371   }
24372
24373   jresult = new Dali::Texture((const Dali::Texture &)result);
24374   return jresult;
24375 }
24376
24377
24378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24379   void * jresult ;
24380   Dali::Texture *result = 0 ;
24381
24382   {
24383     try {
24384       result = (Dali::Texture *)new Dali::Texture();
24385     } catch (std::out_of_range& e) {
24386       {
24387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24388       };
24389     } catch (std::exception& e) {
24390       {
24391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24392       };
24393     } catch (Dali::DaliException e) {
24394       {
24395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24396       };
24397     } catch (...) {
24398       {
24399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24400       };
24401     }
24402   }
24403
24404   jresult = (void *)result;
24405   return jresult;
24406 }
24407
24408
24409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24410   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24411
24412   arg1 = (Dali::Texture *)jarg1;
24413   {
24414     try {
24415       delete arg1;
24416     } catch (std::out_of_range& e) {
24417       {
24418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24419       };
24420     } catch (std::exception& e) {
24421       {
24422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24423       };
24424     } catch (Dali::DaliException e) {
24425       {
24426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24427       };
24428     } catch (...) {
24429       {
24430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24431       };
24432     }
24433   }
24434
24435 }
24436
24437
24438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24439   void * jresult ;
24440   Dali::Texture *arg1 = 0 ;
24441   Dali::Texture *result = 0 ;
24442
24443   arg1 = (Dali::Texture *)jarg1;
24444   if (!arg1) {
24445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24446     return 0;
24447   }
24448   {
24449     try {
24450       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24451     } catch (std::out_of_range& e) {
24452       {
24453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24454       };
24455     } catch (std::exception& e) {
24456       {
24457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24458       };
24459     } catch (Dali::DaliException e) {
24460       {
24461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24462       };
24463     } catch (...) {
24464       {
24465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24466       };
24467     }
24468   }
24469
24470   jresult = (void *)result;
24471   return jresult;
24472 }
24473
24474
24475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24476   void * jresult ;
24477   Dali::BaseHandle arg1 ;
24478   Dali::BaseHandle *argp1 ;
24479   Dali::Texture result;
24480
24481   argp1 = (Dali::BaseHandle *)jarg1;
24482   if (!argp1) {
24483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24484     return 0;
24485   }
24486   arg1 = *argp1;
24487   {
24488     try {
24489       result = Dali::Texture::DownCast(arg1);
24490     } catch (std::out_of_range& e) {
24491       {
24492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (std::exception& e) {
24495       {
24496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24497       };
24498     } catch (Dali::DaliException e) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24501       };
24502     } catch (...) {
24503       {
24504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24505       };
24506     }
24507   }
24508
24509   jresult = new Dali::Texture((const Dali::Texture &)result);
24510   return jresult;
24511 }
24512
24513
24514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24515   void * jresult ;
24516   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24517   Dali::Texture *arg2 = 0 ;
24518   Dali::Texture *result = 0 ;
24519
24520   arg1 = (Dali::Texture *)jarg1;
24521   arg2 = (Dali::Texture *)jarg2;
24522   if (!arg2) {
24523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24524     return 0;
24525   }
24526   {
24527     try {
24528       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24529     } catch (std::out_of_range& e) {
24530       {
24531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (std::exception& e) {
24534       {
24535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (Dali::DaliException e) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547
24548   jresult = (void *)result;
24549   return jresult;
24550 }
24551
24552
24553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24554   unsigned int jresult ;
24555   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24556   Dali::PixelData arg2 ;
24557   Dali::PixelData *argp2 ;
24558   bool result;
24559
24560   arg1 = (Dali::Texture *)jarg1;
24561   argp2 = (Dali::PixelData *)jarg2;
24562   if (!argp2) {
24563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24564     return 0;
24565   }
24566   arg2 = *argp2;
24567   {
24568     try {
24569       result = (bool)(arg1)->Upload(arg2);
24570     } catch (std::out_of_range& e) {
24571       {
24572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24573       };
24574     } catch (std::exception& e) {
24575       {
24576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24577       };
24578     } catch (Dali::DaliException e) {
24579       {
24580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24581       };
24582     } catch (...) {
24583       {
24584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24585       };
24586     }
24587   }
24588
24589   jresult = result;
24590   return jresult;
24591 }
24592
24593
24594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24595   unsigned int jresult ;
24596   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24597   Dali::PixelData arg2 ;
24598   unsigned int arg3 ;
24599   unsigned int arg4 ;
24600   unsigned int arg5 ;
24601   unsigned int arg6 ;
24602   unsigned int arg7 ;
24603   unsigned int arg8 ;
24604   Dali::PixelData *argp2 ;
24605   bool result;
24606
24607   arg1 = (Dali::Texture *)jarg1;
24608   argp2 = (Dali::PixelData *)jarg2;
24609   if (!argp2) {
24610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24611     return 0;
24612   }
24613   arg2 = *argp2;
24614   arg3 = (unsigned int)jarg3;
24615   arg4 = (unsigned int)jarg4;
24616   arg5 = (unsigned int)jarg5;
24617   arg6 = (unsigned int)jarg6;
24618   arg7 = (unsigned int)jarg7;
24619   arg8 = (unsigned int)jarg8;
24620   {
24621     try {
24622       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24623     } catch (std::out_of_range& e) {
24624       {
24625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24626       };
24627     } catch (std::exception& e) {
24628       {
24629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24630       };
24631     } catch (Dali::DaliException e) {
24632       {
24633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24634       };
24635     } catch (...) {
24636       {
24637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24638       };
24639     }
24640   }
24641
24642   jresult = result;
24643   return jresult;
24644 }
24645
24646
24647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24648   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24649
24650   arg1 = (Dali::Texture *)jarg1;
24651   {
24652     try {
24653       (arg1)->GenerateMipmaps();
24654     } catch (std::out_of_range& e) {
24655       {
24656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24657       };
24658     } catch (std::exception& e) {
24659       {
24660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24661       };
24662     } catch (Dali::DaliException e) {
24663       {
24664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24665       };
24666     } catch (...) {
24667       {
24668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24669       };
24670     }
24671   }
24672
24673 }
24674
24675
24676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24677   unsigned int jresult ;
24678   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24679   unsigned int result;
24680
24681   arg1 = (Dali::Texture *)jarg1;
24682   {
24683     try {
24684       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24685     } catch (std::out_of_range& e) {
24686       {
24687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24688       };
24689     } catch (std::exception& e) {
24690       {
24691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24692       };
24693     } catch (Dali::DaliException e) {
24694       {
24695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24696       };
24697     } catch (...) {
24698       {
24699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24700       };
24701     }
24702   }
24703
24704   jresult = result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24710   unsigned int jresult ;
24711   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24712   unsigned int result;
24713
24714   arg1 = (Dali::Texture *)jarg1;
24715   {
24716     try {
24717       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24718     } catch (std::out_of_range& e) {
24719       {
24720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24721       };
24722     } catch (std::exception& e) {
24723       {
24724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24725       };
24726     } catch (Dali::DaliException e) {
24727       {
24728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24729       };
24730     } catch (...) {
24731       {
24732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24733       };
24734     }
24735   }
24736
24737   jresult = result;
24738   return jresult;
24739 }
24740
24741
24742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24743   void * jresult ;
24744   Dali::Sampler result;
24745
24746   {
24747     try {
24748       result = Dali::Sampler::New();
24749     } catch (std::out_of_range& e) {
24750       {
24751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24752       };
24753     } catch (std::exception& e) {
24754       {
24755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24756       };
24757     } catch (Dali::DaliException e) {
24758       {
24759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24760       };
24761     } catch (...) {
24762       {
24763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24764       };
24765     }
24766   }
24767
24768   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24769   return jresult;
24770 }
24771
24772
24773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24774   void * jresult ;
24775   Dali::Sampler *result = 0 ;
24776
24777   {
24778     try {
24779       result = (Dali::Sampler *)new Dali::Sampler();
24780     } catch (std::out_of_range& e) {
24781       {
24782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (std::exception& e) {
24785       {
24786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24787       };
24788     } catch (Dali::DaliException e) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24791       };
24792     } catch (...) {
24793       {
24794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24795       };
24796     }
24797   }
24798
24799   jresult = (void *)result;
24800   return jresult;
24801 }
24802
24803
24804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24805   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24806
24807   arg1 = (Dali::Sampler *)jarg1;
24808   {
24809     try {
24810       delete arg1;
24811     } catch (std::out_of_range& e) {
24812       {
24813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (std::exception& e) {
24816       {
24817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24818       };
24819     } catch (Dali::DaliException e) {
24820       {
24821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24822       };
24823     } catch (...) {
24824       {
24825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24826       };
24827     }
24828   }
24829
24830 }
24831
24832
24833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24834   void * jresult ;
24835   Dali::Sampler *arg1 = 0 ;
24836   Dali::Sampler *result = 0 ;
24837
24838   arg1 = (Dali::Sampler *)jarg1;
24839   if (!arg1) {
24840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24841     return 0;
24842   }
24843   {
24844     try {
24845       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24846     } catch (std::out_of_range& e) {
24847       {
24848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24849       };
24850     } catch (std::exception& e) {
24851       {
24852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24853       };
24854     } catch (Dali::DaliException e) {
24855       {
24856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24857       };
24858     } catch (...) {
24859       {
24860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24861       };
24862     }
24863   }
24864
24865   jresult = (void *)result;
24866   return jresult;
24867 }
24868
24869
24870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24871   void * jresult ;
24872   Dali::BaseHandle arg1 ;
24873   Dali::BaseHandle *argp1 ;
24874   Dali::Sampler result;
24875
24876   argp1 = (Dali::BaseHandle *)jarg1;
24877   if (!argp1) {
24878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24879     return 0;
24880   }
24881   arg1 = *argp1;
24882   {
24883     try {
24884       result = Dali::Sampler::DownCast(arg1);
24885     } catch (std::out_of_range& e) {
24886       {
24887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24888       };
24889     } catch (std::exception& e) {
24890       {
24891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24892       };
24893     } catch (Dali::DaliException e) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24896       };
24897     } catch (...) {
24898       {
24899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24900       };
24901     }
24902   }
24903
24904   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24905   return jresult;
24906 }
24907
24908
24909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24910   void * jresult ;
24911   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24912   Dali::Sampler *arg2 = 0 ;
24913   Dali::Sampler *result = 0 ;
24914
24915   arg1 = (Dali::Sampler *)jarg1;
24916   arg2 = (Dali::Sampler *)jarg2;
24917   if (!arg2) {
24918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24919     return 0;
24920   }
24921   {
24922     try {
24923       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24924     } catch (std::out_of_range& e) {
24925       {
24926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24927       };
24928     } catch (std::exception& e) {
24929       {
24930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24931       };
24932     } catch (Dali::DaliException e) {
24933       {
24934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24935       };
24936     } catch (...) {
24937       {
24938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24939       };
24940     }
24941   }
24942
24943   jresult = (void *)result;
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24949   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24950   Dali::FilterMode::Type arg2 ;
24951   Dali::FilterMode::Type arg3 ;
24952
24953   arg1 = (Dali::Sampler *)jarg1;
24954   arg2 = (Dali::FilterMode::Type)jarg2;
24955   arg3 = (Dali::FilterMode::Type)jarg3;
24956   {
24957     try {
24958       (arg1)->SetFilterMode(arg2,arg3);
24959     } catch (std::out_of_range& e) {
24960       {
24961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24962       };
24963     } catch (std::exception& e) {
24964       {
24965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24966       };
24967     } catch (Dali::DaliException e) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24970       };
24971     } catch (...) {
24972       {
24973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24974       };
24975     }
24976   }
24977
24978 }
24979
24980
24981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24982   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24983   Dali::WrapMode::Type arg2 ;
24984   Dali::WrapMode::Type arg3 ;
24985
24986   arg1 = (Dali::Sampler *)jarg1;
24987   arg2 = (Dali::WrapMode::Type)jarg2;
24988   arg3 = (Dali::WrapMode::Type)jarg3;
24989   {
24990     try {
24991       (arg1)->SetWrapMode(arg2,arg3);
24992     } catch (std::out_of_range& e) {
24993       {
24994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24995       };
24996     } catch (std::exception& e) {
24997       {
24998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24999       };
25000     } catch (Dali::DaliException e) {
25001       {
25002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25003       };
25004     } catch (...) {
25005       {
25006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25007       };
25008     }
25009   }
25010
25011 }
25012
25013
25014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25015   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25016   Dali::WrapMode::Type arg2 ;
25017   Dali::WrapMode::Type arg3 ;
25018   Dali::WrapMode::Type arg4 ;
25019
25020   arg1 = (Dali::Sampler *)jarg1;
25021   arg2 = (Dali::WrapMode::Type)jarg2;
25022   arg3 = (Dali::WrapMode::Type)jarg3;
25023   arg4 = (Dali::WrapMode::Type)jarg4;
25024   {
25025     try {
25026       (arg1)->SetWrapMode(arg2,arg3,arg4);
25027     } catch (std::out_of_range& e) {
25028       {
25029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25030       };
25031     } catch (std::exception& e) {
25032       {
25033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25034       };
25035     } catch (Dali::DaliException e) {
25036       {
25037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25038       };
25039     } catch (...) {
25040       {
25041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25042       };
25043     }
25044   }
25045
25046 }
25047
25048
25049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25050   void * jresult ;
25051   Dali::TextureSet result;
25052
25053   {
25054     try {
25055       result = Dali::TextureSet::New();
25056     } catch (std::out_of_range& e) {
25057       {
25058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25059       };
25060     } catch (std::exception& e) {
25061       {
25062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25063       };
25064     } catch (Dali::DaliException e) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25067       };
25068     } catch (...) {
25069       {
25070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25071       };
25072     }
25073   }
25074
25075   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25076   return jresult;
25077 }
25078
25079
25080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25081   void * jresult ;
25082   Dali::TextureSet *result = 0 ;
25083
25084   {
25085     try {
25086       result = (Dali::TextureSet *)new Dali::TextureSet();
25087     } catch (std::out_of_range& e) {
25088       {
25089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25090       };
25091     } catch (std::exception& e) {
25092       {
25093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25094       };
25095     } catch (Dali::DaliException e) {
25096       {
25097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25098       };
25099     } catch (...) {
25100       {
25101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25102       };
25103     }
25104   }
25105
25106   jresult = (void *)result;
25107   return jresult;
25108 }
25109
25110
25111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25112   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25113
25114   arg1 = (Dali::TextureSet *)jarg1;
25115   {
25116     try {
25117       delete arg1;
25118     } catch (std::out_of_range& e) {
25119       {
25120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25121       };
25122     } catch (std::exception& e) {
25123       {
25124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25125       };
25126     } catch (Dali::DaliException e) {
25127       {
25128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25129       };
25130     } catch (...) {
25131       {
25132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25133       };
25134     }
25135   }
25136
25137 }
25138
25139
25140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25141   void * jresult ;
25142   Dali::TextureSet *arg1 = 0 ;
25143   Dali::TextureSet *result = 0 ;
25144
25145   arg1 = (Dali::TextureSet *)jarg1;
25146   if (!arg1) {
25147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25148     return 0;
25149   }
25150   {
25151     try {
25152       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25153     } catch (std::out_of_range& e) {
25154       {
25155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25156       };
25157     } catch (std::exception& e) {
25158       {
25159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25160       };
25161     } catch (Dali::DaliException e) {
25162       {
25163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25164       };
25165     } catch (...) {
25166       {
25167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25168       };
25169     }
25170   }
25171
25172   jresult = (void *)result;
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25178   void * jresult ;
25179   Dali::BaseHandle arg1 ;
25180   Dali::BaseHandle *argp1 ;
25181   Dali::TextureSet result;
25182
25183   argp1 = (Dali::BaseHandle *)jarg1;
25184   if (!argp1) {
25185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25186     return 0;
25187   }
25188   arg1 = *argp1;
25189   {
25190     try {
25191       result = Dali::TextureSet::DownCast(arg1);
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25199       };
25200     } catch (Dali::DaliException e) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25203       };
25204     } catch (...) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25207       };
25208     }
25209   }
25210
25211   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25212   return jresult;
25213 }
25214
25215
25216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25217   void * jresult ;
25218   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25219   Dali::TextureSet *arg2 = 0 ;
25220   Dali::TextureSet *result = 0 ;
25221
25222   arg1 = (Dali::TextureSet *)jarg1;
25223   arg2 = (Dali::TextureSet *)jarg2;
25224   if (!arg2) {
25225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25226     return 0;
25227   }
25228   {
25229     try {
25230       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25231     } catch (std::out_of_range& e) {
25232       {
25233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25234       };
25235     } catch (std::exception& e) {
25236       {
25237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25238       };
25239     } catch (Dali::DaliException e) {
25240       {
25241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25242       };
25243     } catch (...) {
25244       {
25245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25246       };
25247     }
25248   }
25249
25250   jresult = (void *)result;
25251   return jresult;
25252 }
25253
25254
25255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25256   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25257   size_t arg2 ;
25258   Dali::Texture arg3 ;
25259   Dali::Texture *argp3 ;
25260
25261   arg1 = (Dali::TextureSet *)jarg1;
25262   arg2 = (size_t)jarg2;
25263   argp3 = (Dali::Texture *)jarg3;
25264   if (!argp3) {
25265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25266     return ;
25267   }
25268   arg3 = *argp3;
25269   {
25270     try {
25271       (arg1)->SetTexture(arg2,arg3);
25272     } catch (std::out_of_range& e) {
25273       {
25274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25275       };
25276     } catch (std::exception& e) {
25277       {
25278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25279       };
25280     } catch (Dali::DaliException e) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25283       };
25284     } catch (...) {
25285       {
25286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25287       };
25288     }
25289   }
25290
25291 }
25292
25293
25294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25295   void * jresult ;
25296   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25297   size_t arg2 ;
25298   Dali::Texture result;
25299
25300   arg1 = (Dali::TextureSet *)jarg1;
25301   arg2 = (size_t)jarg2;
25302   {
25303     try {
25304       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25305     } catch (std::out_of_range& e) {
25306       {
25307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25308       };
25309     } catch (std::exception& e) {
25310       {
25311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25312       };
25313     } catch (Dali::DaliException e) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25316       };
25317     } catch (...) {
25318       {
25319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25320       };
25321     }
25322   }
25323
25324   jresult = new Dali::Texture((const Dali::Texture &)result);
25325   return jresult;
25326 }
25327
25328
25329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25330   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25331   size_t arg2 ;
25332   Dali::Sampler arg3 ;
25333   Dali::Sampler *argp3 ;
25334
25335   arg1 = (Dali::TextureSet *)jarg1;
25336   arg2 = (size_t)jarg2;
25337   argp3 = (Dali::Sampler *)jarg3;
25338   if (!argp3) {
25339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25340     return ;
25341   }
25342   arg3 = *argp3;
25343   {
25344     try {
25345       (arg1)->SetSampler(arg2,arg3);
25346     } catch (std::out_of_range& e) {
25347       {
25348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25349       };
25350     } catch (std::exception& e) {
25351       {
25352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25353       };
25354     } catch (Dali::DaliException e) {
25355       {
25356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25357       };
25358     } catch (...) {
25359       {
25360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25361       };
25362     }
25363   }
25364
25365 }
25366
25367
25368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25369   void * jresult ;
25370   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25371   size_t arg2 ;
25372   Dali::Sampler result;
25373
25374   arg1 = (Dali::TextureSet *)jarg1;
25375   arg2 = (size_t)jarg2;
25376   {
25377     try {
25378       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25379     } catch (std::out_of_range& e) {
25380       {
25381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25382       };
25383     } catch (std::exception& e) {
25384       {
25385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25386       };
25387     } catch (Dali::DaliException e) {
25388       {
25389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25390       };
25391     } catch (...) {
25392       {
25393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25394       };
25395     }
25396   }
25397
25398   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25399   return jresult;
25400 }
25401
25402
25403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25404   unsigned long jresult ;
25405   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25406   size_t result;
25407
25408   arg1 = (Dali::TextureSet *)jarg1;
25409   {
25410     try {
25411       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25412     } catch (std::out_of_range& e) {
25413       {
25414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25415       };
25416     } catch (std::exception& e) {
25417       {
25418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25419       };
25420     } catch (Dali::DaliException e) {
25421       {
25422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25423       };
25424     } catch (...) {
25425       {
25426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25427       };
25428     }
25429   }
25430
25431   jresult = (unsigned long)result;
25432   return jresult;
25433 }
25434
25435
25436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25437   void * jresult ;
25438   Dali::Property::Map *arg1 = 0 ;
25439   Dali::PropertyBuffer result;
25440
25441   arg1 = (Dali::Property::Map *)jarg1;
25442   if (!arg1) {
25443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25444     return 0;
25445   }
25446   {
25447     try {
25448       result = Dali::PropertyBuffer::New(*arg1);
25449     } catch (std::out_of_range& e) {
25450       {
25451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25452       };
25453     } catch (std::exception& e) {
25454       {
25455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (Dali::DaliException e) {
25458       {
25459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25460       };
25461     } catch (...) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25464       };
25465     }
25466   }
25467
25468   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25469   return jresult;
25470 }
25471
25472
25473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25474   void * jresult ;
25475   Dali::PropertyBuffer *result = 0 ;
25476
25477   {
25478     try {
25479       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25480     } catch (std::out_of_range& e) {
25481       {
25482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25483       };
25484     } catch (std::exception& e) {
25485       {
25486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (Dali::DaliException e) {
25489       {
25490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25491       };
25492     } catch (...) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25495       };
25496     }
25497   }
25498
25499   jresult = (void *)result;
25500   return jresult;
25501 }
25502
25503
25504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25505   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25506
25507   arg1 = (Dali::PropertyBuffer *)jarg1;
25508   {
25509     try {
25510       delete arg1;
25511     } catch (std::out_of_range& e) {
25512       {
25513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25514       };
25515     } catch (std::exception& e) {
25516       {
25517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25518       };
25519     } catch (Dali::DaliException e) {
25520       {
25521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25522       };
25523     } catch (...) {
25524       {
25525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25526       };
25527     }
25528   }
25529
25530 }
25531
25532
25533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25534   void * jresult ;
25535   Dali::PropertyBuffer *arg1 = 0 ;
25536   Dali::PropertyBuffer *result = 0 ;
25537
25538   arg1 = (Dali::PropertyBuffer *)jarg1;
25539   if (!arg1) {
25540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25541     return 0;
25542   }
25543   {
25544     try {
25545       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25546     } catch (std::out_of_range& e) {
25547       {
25548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25549       };
25550     } catch (std::exception& e) {
25551       {
25552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25553       };
25554     } catch (Dali::DaliException e) {
25555       {
25556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25557       };
25558     } catch (...) {
25559       {
25560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25561       };
25562     }
25563   }
25564
25565   jresult = (void *)result;
25566   return jresult;
25567 }
25568
25569
25570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25571   void * jresult ;
25572   Dali::BaseHandle arg1 ;
25573   Dali::BaseHandle *argp1 ;
25574   Dali::PropertyBuffer result;
25575
25576   argp1 = (Dali::BaseHandle *)jarg1;
25577   if (!argp1) {
25578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25579     return 0;
25580   }
25581   arg1 = *argp1;
25582   {
25583     try {
25584       result = Dali::PropertyBuffer::DownCast(arg1);
25585     } catch (std::out_of_range& e) {
25586       {
25587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25588       };
25589     } catch (std::exception& e) {
25590       {
25591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25592       };
25593     } catch (Dali::DaliException e) {
25594       {
25595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25596       };
25597     } catch (...) {
25598       {
25599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25600       };
25601     }
25602   }
25603
25604   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25605   return jresult;
25606 }
25607
25608
25609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25610   void * jresult ;
25611   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25612   Dali::PropertyBuffer *arg2 = 0 ;
25613   Dali::PropertyBuffer *result = 0 ;
25614
25615   arg1 = (Dali::PropertyBuffer *)jarg1;
25616   arg2 = (Dali::PropertyBuffer *)jarg2;
25617   if (!arg2) {
25618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25619     return 0;
25620   }
25621   {
25622     try {
25623       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25624     } catch (std::out_of_range& e) {
25625       {
25626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (std::exception& e) {
25629       {
25630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25631       };
25632     } catch (Dali::DaliException e) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25635       };
25636     } catch (...) {
25637       {
25638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25639       };
25640     }
25641   }
25642
25643   jresult = (void *)result;
25644   return jresult;
25645 }
25646
25647
25648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25649   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25650   void *arg2 = (void *) 0 ;
25651   std::size_t arg3 ;
25652
25653   arg1 = (Dali::PropertyBuffer *)jarg1;
25654   arg2 = jarg2;
25655   arg3 = (std::size_t)jarg3;
25656   {
25657     try {
25658       (arg1)->SetData((void const *)arg2,arg3);
25659     } catch (std::out_of_range& e) {
25660       {
25661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25662       };
25663     } catch (std::exception& e) {
25664       {
25665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25666       };
25667     } catch (Dali::DaliException e) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25670       };
25671     } catch (...) {
25672       {
25673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25674       };
25675     }
25676   }
25677
25678 }
25679
25680
25681 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25682   unsigned long jresult ;
25683   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25684   std::size_t result;
25685
25686   arg1 = (Dali::PropertyBuffer *)jarg1;
25687   {
25688     try {
25689       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25690     } catch (std::out_of_range& e) {
25691       {
25692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25693       };
25694     } catch (std::exception& e) {
25695       {
25696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25697       };
25698     } catch (Dali::DaliException e) {
25699       {
25700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25701       };
25702     } catch (...) {
25703       {
25704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25705       };
25706     }
25707   }
25708
25709   jresult = (unsigned long)result;
25710   return jresult;
25711 }
25712
25713
25714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25715   void * jresult ;
25716   Dali::Geometry result;
25717
25718   {
25719     try {
25720       result = Dali::Geometry::New();
25721     } catch (std::out_of_range& e) {
25722       {
25723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25724       };
25725     } catch (std::exception& e) {
25726       {
25727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25728       };
25729     } catch (Dali::DaliException e) {
25730       {
25731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25732       };
25733     } catch (...) {
25734       {
25735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25736       };
25737     }
25738   }
25739
25740   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25741   return jresult;
25742 }
25743
25744
25745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25746   void * jresult ;
25747   Dali::Geometry *result = 0 ;
25748
25749   {
25750     try {
25751       result = (Dali::Geometry *)new Dali::Geometry();
25752     } catch (std::out_of_range& e) {
25753       {
25754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (std::exception& e) {
25757       {
25758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25759       };
25760     } catch (Dali::DaliException e) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25763       };
25764     } catch (...) {
25765       {
25766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25767       };
25768     }
25769   }
25770
25771   jresult = (void *)result;
25772   return jresult;
25773 }
25774
25775
25776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25777   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25778
25779   arg1 = (Dali::Geometry *)jarg1;
25780   {
25781     try {
25782       delete arg1;
25783     } catch (std::out_of_range& e) {
25784       {
25785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25786       };
25787     } catch (std::exception& e) {
25788       {
25789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25790       };
25791     } catch (Dali::DaliException e) {
25792       {
25793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25794       };
25795     } catch (...) {
25796       {
25797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25798       };
25799     }
25800   }
25801
25802 }
25803
25804
25805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25806   void * jresult ;
25807   Dali::Geometry *arg1 = 0 ;
25808   Dali::Geometry *result = 0 ;
25809
25810   arg1 = (Dali::Geometry *)jarg1;
25811   if (!arg1) {
25812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25813     return 0;
25814   }
25815   {
25816     try {
25817       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25818     } catch (std::out_of_range& e) {
25819       {
25820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (std::exception& e) {
25823       {
25824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25825       };
25826     } catch (Dali::DaliException e) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25829       };
25830     } catch (...) {
25831       {
25832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25833       };
25834     }
25835   }
25836
25837   jresult = (void *)result;
25838   return jresult;
25839 }
25840
25841
25842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25843   void * jresult ;
25844   Dali::BaseHandle arg1 ;
25845   Dali::BaseHandle *argp1 ;
25846   Dali::Geometry result;
25847
25848   argp1 = (Dali::BaseHandle *)jarg1;
25849   if (!argp1) {
25850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25851     return 0;
25852   }
25853   arg1 = *argp1;
25854   {
25855     try {
25856       result = Dali::Geometry::DownCast(arg1);
25857     } catch (std::out_of_range& e) {
25858       {
25859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (std::exception& e) {
25862       {
25863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25864       };
25865     } catch (Dali::DaliException e) {
25866       {
25867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25868       };
25869     } catch (...) {
25870       {
25871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25872       };
25873     }
25874   }
25875
25876   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25877   return jresult;
25878 }
25879
25880
25881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25882   void * jresult ;
25883   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25884   Dali::Geometry *arg2 = 0 ;
25885   Dali::Geometry *result = 0 ;
25886
25887   arg1 = (Dali::Geometry *)jarg1;
25888   arg2 = (Dali::Geometry *)jarg2;
25889   if (!arg2) {
25890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25891     return 0;
25892   }
25893   {
25894     try {
25895       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25896     } catch (std::out_of_range& e) {
25897       {
25898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25899       };
25900     } catch (std::exception& e) {
25901       {
25902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25903       };
25904     } catch (Dali::DaliException e) {
25905       {
25906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25907       };
25908     } catch (...) {
25909       {
25910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25911       };
25912     }
25913   }
25914
25915   jresult = (void *)result;
25916   return jresult;
25917 }
25918
25919
25920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25921   unsigned long jresult ;
25922   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25923   Dali::PropertyBuffer *arg2 = 0 ;
25924   std::size_t result;
25925
25926   arg1 = (Dali::Geometry *)jarg1;
25927   arg2 = (Dali::PropertyBuffer *)jarg2;
25928   if (!arg2) {
25929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25930     return 0;
25931   }
25932   {
25933     try {
25934       result = (arg1)->AddVertexBuffer(*arg2);
25935     } catch (std::out_of_range& e) {
25936       {
25937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25938       };
25939     } catch (std::exception& e) {
25940       {
25941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25942       };
25943     } catch (Dali::DaliException e) {
25944       {
25945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25946       };
25947     } catch (...) {
25948       {
25949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25950       };
25951     }
25952   }
25953
25954   jresult = (unsigned long)result;
25955   return jresult;
25956 }
25957
25958
25959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25960   unsigned long jresult ;
25961   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25962   std::size_t result;
25963
25964   arg1 = (Dali::Geometry *)jarg1;
25965   {
25966     try {
25967       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25968     } catch (std::out_of_range& e) {
25969       {
25970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25971       };
25972     } catch (std::exception& e) {
25973       {
25974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25975       };
25976     } catch (Dali::DaliException e) {
25977       {
25978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25979       };
25980     } catch (...) {
25981       {
25982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25983       };
25984     }
25985   }
25986
25987   jresult = (unsigned long)result;
25988   return jresult;
25989 }
25990
25991
25992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25993   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25994   std::size_t arg2 ;
25995
25996   arg1 = (Dali::Geometry *)jarg1;
25997   arg2 = (std::size_t)jarg2;
25998   {
25999     try {
26000       (arg1)->RemoveVertexBuffer(arg2);
26001     } catch (std::out_of_range& e) {
26002       {
26003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26004       };
26005     } catch (std::exception& e) {
26006       {
26007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26008       };
26009     } catch (Dali::DaliException e) {
26010       {
26011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26012       };
26013     } catch (...) {
26014       {
26015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26016       };
26017     }
26018   }
26019
26020 }
26021
26022
26023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26024   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26025   unsigned short *arg2 = (unsigned short *) 0 ;
26026   size_t arg3 ;
26027
26028   arg1 = (Dali::Geometry *)jarg1;
26029   arg2 = jarg2;
26030   arg3 = (size_t)jarg3;
26031   {
26032     try {
26033       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26034     } catch (std::out_of_range& e) {
26035       {
26036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26037       };
26038     } catch (std::exception& e) {
26039       {
26040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26041       };
26042     } catch (Dali::DaliException e) {
26043       {
26044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26045       };
26046     } catch (...) {
26047       {
26048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26049       };
26050     }
26051   }
26052
26053
26054
26055 }
26056
26057
26058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26059   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26060   Dali::Geometry::Type arg2 ;
26061
26062   arg1 = (Dali::Geometry *)jarg1;
26063   arg2 = (Dali::Geometry::Type)jarg2;
26064   {
26065     try {
26066       (arg1)->SetType(arg2);
26067     } catch (std::out_of_range& e) {
26068       {
26069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26070       };
26071     } catch (std::exception& e) {
26072       {
26073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26074       };
26075     } catch (Dali::DaliException e) {
26076       {
26077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26078       };
26079     } catch (...) {
26080       {
26081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26082       };
26083     }
26084   }
26085
26086 }
26087
26088
26089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26090   int jresult ;
26091   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26092   Dali::Geometry::Type result;
26093
26094   arg1 = (Dali::Geometry *)jarg1;
26095   {
26096     try {
26097       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26098     } catch (std::out_of_range& e) {
26099       {
26100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26101       };
26102     } catch (std::exception& e) {
26103       {
26104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26105       };
26106     } catch (Dali::DaliException e) {
26107       {
26108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26109       };
26110     } catch (...) {
26111       {
26112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26113       };
26114     }
26115   }
26116
26117   jresult = (int)result;
26118   return jresult;
26119 }
26120
26121
26122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26123   void * jresult ;
26124   Dali::Shader::Hint *result = 0 ;
26125
26126   {
26127     try {
26128       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26129     } catch (std::out_of_range& e) {
26130       {
26131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26132       };
26133     } catch (std::exception& e) {
26134       {
26135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26136       };
26137     } catch (Dali::DaliException e) {
26138       {
26139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26140       };
26141     } catch (...) {
26142       {
26143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26144       };
26145     }
26146   }
26147
26148   jresult = (void *)result;
26149   return jresult;
26150 }
26151
26152
26153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26154   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26155
26156   arg1 = (Dali::Shader::Hint *)jarg1;
26157   {
26158     try {
26159       delete arg1;
26160     } catch (std::out_of_range& e) {
26161       {
26162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26163       };
26164     } catch (std::exception& e) {
26165       {
26166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26167       };
26168     } catch (Dali::DaliException e) {
26169       {
26170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26171       };
26172     } catch (...) {
26173       {
26174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26175       };
26176     }
26177   }
26178
26179 }
26180
26181
26182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26183   int jresult ;
26184   int result;
26185
26186   result = (int)Dali::Shader::Property::PROGRAM;
26187   jresult = (int)result;
26188   return jresult;
26189 }
26190
26191
26192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26193   void * jresult ;
26194   Dali::Shader::Property *result = 0 ;
26195
26196   {
26197     try {
26198       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26199     } catch (std::out_of_range& e) {
26200       {
26201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26202       };
26203     } catch (std::exception& e) {
26204       {
26205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26206       };
26207     } catch (Dali::DaliException e) {
26208       {
26209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26210       };
26211     } catch (...) {
26212       {
26213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26214       };
26215     }
26216   }
26217
26218   jresult = (void *)result;
26219   return jresult;
26220 }
26221
26222
26223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26224   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26225
26226   arg1 = (Dali::Shader::Property *)jarg1;
26227   {
26228     try {
26229       delete arg1;
26230     } catch (std::out_of_range& e) {
26231       {
26232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26233       };
26234     } catch (std::exception& e) {
26235       {
26236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26237       };
26238     } catch (Dali::DaliException e) {
26239       {
26240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26241       };
26242     } catch (...) {
26243       {
26244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26245       };
26246     }
26247   }
26248
26249 }
26250
26251
26252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26253   void * jresult ;
26254   std::string *arg1 = 0 ;
26255   std::string *arg2 = 0 ;
26256   Dali::Shader::Hint::Value arg3 ;
26257   Dali::Shader result;
26258
26259   if (!jarg1) {
26260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26261     return 0;
26262   }
26263   std::string arg1_str(jarg1);
26264   arg1 = &arg1_str;
26265   if (!jarg2) {
26266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26267     return 0;
26268   }
26269   std::string arg2_str(jarg2);
26270   arg2 = &arg2_str;
26271   arg3 = (Dali::Shader::Hint::Value)jarg3;
26272   {
26273     try {
26274       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26275     } catch (std::out_of_range& e) {
26276       {
26277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26278       };
26279     } catch (std::exception& e) {
26280       {
26281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (Dali::DaliException e) {
26284       {
26285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26286       };
26287     } catch (...) {
26288       {
26289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26290       };
26291     }
26292   }
26293
26294   jresult = new Dali::Shader((const Dali::Shader &)result);
26295
26296   //argout typemap for const std::string&
26297
26298
26299   //argout typemap for const std::string&
26300
26301   return jresult;
26302 }
26303
26304
26305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26306   void * jresult ;
26307   std::string *arg1 = 0 ;
26308   std::string *arg2 = 0 ;
26309   Dali::Shader result;
26310
26311   if (!jarg1) {
26312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26313     return 0;
26314   }
26315   std::string arg1_str(jarg1);
26316   arg1 = &arg1_str;
26317   if (!jarg2) {
26318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26319     return 0;
26320   }
26321   std::string arg2_str(jarg2);
26322   arg2 = &arg2_str;
26323   {
26324     try {
26325       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26326     } catch (std::out_of_range& e) {
26327       {
26328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26329       };
26330     } catch (std::exception& e) {
26331       {
26332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26333       };
26334     } catch (Dali::DaliException e) {
26335       {
26336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26337       };
26338     } catch (...) {
26339       {
26340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26341       };
26342     }
26343   }
26344
26345   jresult = new Dali::Shader((const Dali::Shader &)result);
26346
26347   //argout typemap for const std::string&
26348
26349
26350   //argout typemap for const std::string&
26351
26352   return jresult;
26353 }
26354
26355
26356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26357   void * jresult ;
26358   Dali::Shader *result = 0 ;
26359
26360   {
26361     try {
26362       result = (Dali::Shader *)new Dali::Shader();
26363     } catch (std::out_of_range& e) {
26364       {
26365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26366       };
26367     } catch (std::exception& e) {
26368       {
26369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26370       };
26371     } catch (Dali::DaliException e) {
26372       {
26373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26374       };
26375     } catch (...) {
26376       {
26377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26378       };
26379     }
26380   }
26381
26382   jresult = (void *)result;
26383   return jresult;
26384 }
26385
26386
26387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26388   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26389
26390   arg1 = (Dali::Shader *)jarg1;
26391   {
26392     try {
26393       delete arg1;
26394     } catch (std::out_of_range& e) {
26395       {
26396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26397       };
26398     } catch (std::exception& e) {
26399       {
26400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26401       };
26402     } catch (Dali::DaliException e) {
26403       {
26404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26405       };
26406     } catch (...) {
26407       {
26408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26409       };
26410     }
26411   }
26412
26413 }
26414
26415
26416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26417   void * jresult ;
26418   Dali::Shader *arg1 = 0 ;
26419   Dali::Shader *result = 0 ;
26420
26421   arg1 = (Dali::Shader *)jarg1;
26422   if (!arg1) {
26423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26424     return 0;
26425   }
26426   {
26427     try {
26428       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26429     } catch (std::out_of_range& e) {
26430       {
26431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (std::exception& e) {
26434       {
26435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (Dali::DaliException e) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26440       };
26441     } catch (...) {
26442       {
26443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26444       };
26445     }
26446   }
26447
26448   jresult = (void *)result;
26449   return jresult;
26450 }
26451
26452
26453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26454   void * jresult ;
26455   Dali::BaseHandle arg1 ;
26456   Dali::BaseHandle *argp1 ;
26457   Dali::Shader result;
26458
26459   argp1 = (Dali::BaseHandle *)jarg1;
26460   if (!argp1) {
26461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26462     return 0;
26463   }
26464   arg1 = *argp1;
26465   {
26466     try {
26467       result = Dali::Shader::DownCast(arg1);
26468     } catch (std::out_of_range& e) {
26469       {
26470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26471       };
26472     } catch (std::exception& e) {
26473       {
26474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26475       };
26476     } catch (Dali::DaliException e) {
26477       {
26478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26479       };
26480     } catch (...) {
26481       {
26482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26483       };
26484     }
26485   }
26486
26487   jresult = new Dali::Shader((const Dali::Shader &)result);
26488   return jresult;
26489 }
26490
26491
26492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26493   void * jresult ;
26494   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26495   Dali::Shader *arg2 = 0 ;
26496   Dali::Shader *result = 0 ;
26497
26498   arg1 = (Dali::Shader *)jarg1;
26499   arg2 = (Dali::Shader *)jarg2;
26500   if (!arg2) {
26501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26502     return 0;
26503   }
26504   {
26505     try {
26506       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26507     } catch (std::out_of_range& e) {
26508       {
26509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26510       };
26511     } catch (std::exception& e) {
26512       {
26513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26514       };
26515     } catch (Dali::DaliException e) {
26516       {
26517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26518       };
26519     } catch (...) {
26520       {
26521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26522       };
26523     }
26524   }
26525
26526   jresult = (void *)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26532   int jresult ;
26533   int result;
26534
26535   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26536   jresult = (int)result;
26537   return jresult;
26538 }
26539
26540
26541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26542   int jresult ;
26543   int result;
26544
26545   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26546   jresult = (int)result;
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26552   int jresult ;
26553   int result;
26554
26555   result = (int)Dali::Renderer::Property::BLEND_MODE;
26556   jresult = (int)result;
26557   return jresult;
26558 }
26559
26560
26561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26562   int jresult ;
26563   int result;
26564
26565   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26566   jresult = (int)result;
26567   return jresult;
26568 }
26569
26570
26571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26572   int jresult ;
26573   int result;
26574
26575   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26576   jresult = (int)result;
26577   return jresult;
26578 }
26579
26580
26581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26582   int jresult ;
26583   int result;
26584
26585   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26586   jresult = (int)result;
26587   return jresult;
26588 }
26589
26590
26591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26592   int jresult ;
26593   int result;
26594
26595   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26596   jresult = (int)result;
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26602   int jresult ;
26603   int result;
26604
26605   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26606   jresult = (int)result;
26607   return jresult;
26608 }
26609
26610
26611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26612   int jresult ;
26613   int result;
26614
26615   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26616   jresult = (int)result;
26617   return jresult;
26618 }
26619
26620
26621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26622   int jresult ;
26623   int result;
26624
26625   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26626   jresult = (int)result;
26627   return jresult;
26628 }
26629
26630
26631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26632   int jresult ;
26633   int result;
26634
26635   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26636   jresult = (int)result;
26637   return jresult;
26638 }
26639
26640
26641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26642   int jresult ;
26643   int result;
26644
26645   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26646   jresult = (int)result;
26647   return jresult;
26648 }
26649
26650
26651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26652   int jresult ;
26653   int result;
26654
26655   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26656   jresult = (int)result;
26657   return jresult;
26658 }
26659
26660
26661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26662   int jresult ;
26663   int result;
26664
26665   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26666   jresult = (int)result;
26667   return jresult;
26668 }
26669
26670
26671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26672   int jresult ;
26673   int result;
26674
26675   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26676   jresult = (int)result;
26677   return jresult;
26678 }
26679
26680
26681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26682   int jresult ;
26683   int result;
26684
26685   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26686   jresult = (int)result;
26687   return jresult;
26688 }
26689
26690
26691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26692   int jresult ;
26693   int result;
26694
26695   result = (int)Dali::Renderer::Property::RENDER_MODE;
26696   jresult = (int)result;
26697   return jresult;
26698 }
26699
26700
26701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26702   int jresult ;
26703   int result;
26704
26705   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26706   jresult = (int)result;
26707   return jresult;
26708 }
26709
26710
26711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26712   int jresult ;
26713   int result;
26714
26715   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26716   jresult = (int)result;
26717   return jresult;
26718 }
26719
26720
26721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26722   int jresult ;
26723   int result;
26724
26725   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26726   jresult = (int)result;
26727   return jresult;
26728 }
26729
26730
26731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26732   int jresult ;
26733   int result;
26734
26735   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26736   jresult = (int)result;
26737   return jresult;
26738 }
26739
26740
26741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26742   int jresult ;
26743   int result;
26744
26745   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26746   jresult = (int)result;
26747   return jresult;
26748 }
26749
26750
26751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26752   int jresult ;
26753   int result;
26754
26755   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26756   jresult = (int)result;
26757   return jresult;
26758 }
26759
26760
26761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26762   int jresult ;
26763   int result;
26764
26765   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26766   jresult = (int)result;
26767   return jresult;
26768 }
26769
26770
26771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26772   void * jresult ;
26773   Dali::Renderer::Property *result = 0 ;
26774
26775   {
26776     try {
26777       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26778     } catch (std::out_of_range& e) {
26779       {
26780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26781       };
26782     } catch (std::exception& e) {
26783       {
26784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26785       };
26786     } catch (Dali::DaliException e) {
26787       {
26788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26789       };
26790     } catch (...) {
26791       {
26792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26793       };
26794     }
26795   }
26796
26797   jresult = (void *)result;
26798   return jresult;
26799 }
26800
26801
26802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26803   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26804
26805   arg1 = (Dali::Renderer::Property *)jarg1;
26806   {
26807     try {
26808       delete arg1;
26809     } catch (std::out_of_range& e) {
26810       {
26811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26812       };
26813     } catch (std::exception& e) {
26814       {
26815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26816       };
26817     } catch (Dali::DaliException e) {
26818       {
26819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26820       };
26821     } catch (...) {
26822       {
26823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26824       };
26825     }
26826   }
26827
26828 }
26829
26830
26831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26832   void * jresult ;
26833   Dali::Geometry *arg1 = 0 ;
26834   Dali::Shader *arg2 = 0 ;
26835   Dali::Renderer result;
26836
26837   arg1 = (Dali::Geometry *)jarg1;
26838   if (!arg1) {
26839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26840     return 0;
26841   }
26842   arg2 = (Dali::Shader *)jarg2;
26843   if (!arg2) {
26844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26845     return 0;
26846   }
26847   {
26848     try {
26849       result = Dali::Renderer::New(*arg1,*arg2);
26850     } catch (std::out_of_range& e) {
26851       {
26852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26853       };
26854     } catch (std::exception& e) {
26855       {
26856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26857       };
26858     } catch (Dali::DaliException e) {
26859       {
26860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26861       };
26862     } catch (...) {
26863       {
26864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26865       };
26866     }
26867   }
26868
26869   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26870   return jresult;
26871 }
26872
26873
26874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26875   void * jresult ;
26876   Dali::Renderer *result = 0 ;
26877
26878   {
26879     try {
26880       result = (Dali::Renderer *)new Dali::Renderer();
26881     } catch (std::out_of_range& e) {
26882       {
26883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (std::exception& e) {
26886       {
26887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26888       };
26889     } catch (Dali::DaliException e) {
26890       {
26891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26892       };
26893     } catch (...) {
26894       {
26895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26896       };
26897     }
26898   }
26899
26900   jresult = (void *)result;
26901   return jresult;
26902 }
26903
26904
26905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26906   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26907
26908   arg1 = (Dali::Renderer *)jarg1;
26909   {
26910     try {
26911       delete arg1;
26912     } catch (std::out_of_range& e) {
26913       {
26914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26915       };
26916     } catch (std::exception& e) {
26917       {
26918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26919       };
26920     } catch (Dali::DaliException e) {
26921       {
26922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26923       };
26924     } catch (...) {
26925       {
26926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26927       };
26928     }
26929   }
26930
26931 }
26932
26933
26934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26935   void * jresult ;
26936   Dali::Renderer *arg1 = 0 ;
26937   Dali::Renderer *result = 0 ;
26938
26939   arg1 = (Dali::Renderer *)jarg1;
26940   if (!arg1) {
26941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26942     return 0;
26943   }
26944   {
26945     try {
26946       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26947     } catch (std::out_of_range& e) {
26948       {
26949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26950       };
26951     } catch (std::exception& e) {
26952       {
26953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26954       };
26955     } catch (Dali::DaliException e) {
26956       {
26957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26958       };
26959     } catch (...) {
26960       {
26961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26962       };
26963     }
26964   }
26965
26966   jresult = (void *)result;
26967   return jresult;
26968 }
26969
26970
26971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26972   void * jresult ;
26973   Dali::BaseHandle arg1 ;
26974   Dali::BaseHandle *argp1 ;
26975   Dali::Renderer result;
26976
26977   argp1 = (Dali::BaseHandle *)jarg1;
26978   if (!argp1) {
26979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26980     return 0;
26981   }
26982   arg1 = *argp1;
26983   {
26984     try {
26985       result = Dali::Renderer::DownCast(arg1);
26986     } catch (std::out_of_range& e) {
26987       {
26988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26989       };
26990     } catch (std::exception& e) {
26991       {
26992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26993       };
26994     } catch (Dali::DaliException e) {
26995       {
26996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26997       };
26998     } catch (...) {
26999       {
27000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27001       };
27002     }
27003   }
27004
27005   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27006   return jresult;
27007 }
27008
27009
27010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27011   void * jresult ;
27012   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27013   Dali::Renderer *arg2 = 0 ;
27014   Dali::Renderer *result = 0 ;
27015
27016   arg1 = (Dali::Renderer *)jarg1;
27017   arg2 = (Dali::Renderer *)jarg2;
27018   if (!arg2) {
27019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27020     return 0;
27021   }
27022   {
27023     try {
27024       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27025     } catch (std::out_of_range& e) {
27026       {
27027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27028       };
27029     } catch (std::exception& e) {
27030       {
27031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27032       };
27033     } catch (Dali::DaliException e) {
27034       {
27035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27036       };
27037     } catch (...) {
27038       {
27039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27040       };
27041     }
27042   }
27043
27044   jresult = (void *)result;
27045   return jresult;
27046 }
27047
27048
27049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27050   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27051   Dali::Geometry *arg2 = 0 ;
27052
27053   arg1 = (Dali::Renderer *)jarg1;
27054   arg2 = (Dali::Geometry *)jarg2;
27055   if (!arg2) {
27056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27057     return ;
27058   }
27059   {
27060     try {
27061       (arg1)->SetGeometry(*arg2);
27062     } catch (std::out_of_range& e) {
27063       {
27064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27065       };
27066     } catch (std::exception& e) {
27067       {
27068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27069       };
27070     } catch (Dali::DaliException e) {
27071       {
27072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27073       };
27074     } catch (...) {
27075       {
27076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27077       };
27078     }
27079   }
27080
27081 }
27082
27083
27084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27085   void * jresult ;
27086   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27087   Dali::Geometry result;
27088
27089   arg1 = (Dali::Renderer *)jarg1;
27090   {
27091     try {
27092       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27093     } catch (std::out_of_range& e) {
27094       {
27095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (std::exception& e) {
27098       {
27099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27100       };
27101     } catch (Dali::DaliException e) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27104       };
27105     } catch (...) {
27106       {
27107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27108       };
27109     }
27110   }
27111
27112   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27113   return jresult;
27114 }
27115
27116
27117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27118   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27119   int arg2 ;
27120   int arg3 ;
27121
27122   arg1 = (Dali::Renderer *)jarg1;
27123   arg2 = (int)jarg2;
27124   arg3 = (int)jarg3;
27125   {
27126     try {
27127       (arg1)->SetIndexRange(arg2,arg3);
27128     } catch (std::out_of_range& e) {
27129       {
27130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27131       };
27132     } catch (std::exception& e) {
27133       {
27134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27135       };
27136     } catch (Dali::DaliException e) {
27137       {
27138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27139       };
27140     } catch (...) {
27141       {
27142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27143       };
27144     }
27145   }
27146
27147 }
27148
27149
27150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27151   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27152   Dali::TextureSet *arg2 = 0 ;
27153
27154   arg1 = (Dali::Renderer *)jarg1;
27155   arg2 = (Dali::TextureSet *)jarg2;
27156   if (!arg2) {
27157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27158     return ;
27159   }
27160   {
27161     try {
27162       (arg1)->SetTextures(*arg2);
27163     } catch (std::out_of_range& e) {
27164       {
27165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27166       };
27167     } catch (std::exception& e) {
27168       {
27169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27170       };
27171     } catch (Dali::DaliException e) {
27172       {
27173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27174       };
27175     } catch (...) {
27176       {
27177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27178       };
27179     }
27180   }
27181
27182 }
27183
27184
27185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27186   void * jresult ;
27187   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27188   Dali::TextureSet result;
27189
27190   arg1 = (Dali::Renderer *)jarg1;
27191   {
27192     try {
27193       result = ((Dali::Renderer const *)arg1)->GetTextures();
27194     } catch (std::out_of_range& e) {
27195       {
27196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27197       };
27198     } catch (std::exception& e) {
27199       {
27200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27201       };
27202     } catch (Dali::DaliException e) {
27203       {
27204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27205       };
27206     } catch (...) {
27207       {
27208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27209       };
27210     }
27211   }
27212
27213   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27214   return jresult;
27215 }
27216
27217
27218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27219   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27220   Dali::Shader *arg2 = 0 ;
27221
27222   arg1 = (Dali::Renderer *)jarg1;
27223   arg2 = (Dali::Shader *)jarg2;
27224   if (!arg2) {
27225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27226     return ;
27227   }
27228   {
27229     try {
27230       (arg1)->SetShader(*arg2);
27231     } catch (std::out_of_range& e) {
27232       {
27233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27234       };
27235     } catch (std::exception& e) {
27236       {
27237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27238       };
27239     } catch (Dali::DaliException e) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27242       };
27243     } catch (...) {
27244       {
27245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27246       };
27247     }
27248   }
27249
27250 }
27251
27252
27253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27254   void * jresult ;
27255   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27256   Dali::Shader result;
27257
27258   arg1 = (Dali::Renderer *)jarg1;
27259   {
27260     try {
27261       result = ((Dali::Renderer const *)arg1)->GetShader();
27262     } catch (std::out_of_range& e) {
27263       {
27264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27265       };
27266     } catch (std::exception& e) {
27267       {
27268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27269       };
27270     } catch (Dali::DaliException e) {
27271       {
27272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27273       };
27274     } catch (...) {
27275       {
27276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27277       };
27278     }
27279   }
27280
27281   jresult = new Dali::Shader((const Dali::Shader &)result);
27282   return jresult;
27283 }
27284
27285
27286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27287   void * jresult ;
27288   Dali::FrameBuffer::Attachment *result = 0 ;
27289
27290   {
27291     try {
27292       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27293     } catch (std::out_of_range& e) {
27294       {
27295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (std::exception& e) {
27298       {
27299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27300       };
27301     } catch (Dali::DaliException e) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27304       };
27305     } catch (...) {
27306       {
27307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27308       };
27309     }
27310   }
27311
27312   jresult = (void *)result;
27313   return jresult;
27314 }
27315
27316
27317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27318   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27319
27320   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27321   {
27322     try {
27323       delete arg1;
27324     } catch (std::out_of_range& e) {
27325       {
27326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27327       };
27328     } catch (std::exception& e) {
27329       {
27330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27331       };
27332     } catch (Dali::DaliException e) {
27333       {
27334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27335       };
27336     } catch (...) {
27337       {
27338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27339       };
27340     }
27341   }
27342
27343 }
27344
27345
27346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27347   void * jresult ;
27348   unsigned int arg1 ;
27349   unsigned int arg2 ;
27350   unsigned int arg3 ;
27351   Dali::FrameBuffer result;
27352
27353   arg1 = (unsigned int)jarg1;
27354   arg2 = (unsigned int)jarg2;
27355   arg3 = (unsigned int)jarg3;
27356   {
27357     try {
27358       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27359     } catch (std::out_of_range& e) {
27360       {
27361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27362       };
27363     } catch (std::exception& e) {
27364       {
27365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27366       };
27367     } catch (Dali::DaliException e) {
27368       {
27369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27370       };
27371     } catch (...) {
27372       {
27373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27374       };
27375     }
27376   }
27377
27378   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27379   return jresult;
27380 }
27381
27382
27383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27384   void * jresult ;
27385   Dali::FrameBuffer *result = 0 ;
27386
27387   {
27388     try {
27389       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27390     } catch (std::out_of_range& e) {
27391       {
27392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27393       };
27394     } catch (std::exception& e) {
27395       {
27396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27397       };
27398     } catch (Dali::DaliException e) {
27399       {
27400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27401       };
27402     } catch (...) {
27403       {
27404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27405       };
27406     }
27407   }
27408
27409   jresult = (void *)result;
27410   return jresult;
27411 }
27412
27413
27414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27415   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27416
27417   arg1 = (Dali::FrameBuffer *)jarg1;
27418   {
27419     try {
27420       delete arg1;
27421     } catch (std::out_of_range& e) {
27422       {
27423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27424       };
27425     } catch (std::exception& e) {
27426       {
27427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27428       };
27429     } catch (Dali::DaliException e) {
27430       {
27431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27432       };
27433     } catch (...) {
27434       {
27435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27436       };
27437     }
27438   }
27439
27440 }
27441
27442
27443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27444   void * jresult ;
27445   Dali::FrameBuffer *arg1 = 0 ;
27446   Dali::FrameBuffer *result = 0 ;
27447
27448   arg1 = (Dali::FrameBuffer *)jarg1;
27449   if (!arg1) {
27450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27451     return 0;
27452   }
27453   {
27454     try {
27455       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27456     } catch (std::out_of_range& e) {
27457       {
27458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27459       };
27460     } catch (std::exception& e) {
27461       {
27462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27463       };
27464     } catch (Dali::DaliException e) {
27465       {
27466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27467       };
27468     } catch (...) {
27469       {
27470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27471       };
27472     }
27473   }
27474
27475   jresult = (void *)result;
27476   return jresult;
27477 }
27478
27479
27480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27481   void * jresult ;
27482   Dali::BaseHandle arg1 ;
27483   Dali::BaseHandle *argp1 ;
27484   Dali::FrameBuffer result;
27485
27486   argp1 = (Dali::BaseHandle *)jarg1;
27487   if (!argp1) {
27488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27489     return 0;
27490   }
27491   arg1 = *argp1;
27492   {
27493     try {
27494       result = Dali::FrameBuffer::DownCast(arg1);
27495     } catch (std::out_of_range& e) {
27496       {
27497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27498       };
27499     } catch (std::exception& e) {
27500       {
27501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27502       };
27503     } catch (Dali::DaliException e) {
27504       {
27505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27506       };
27507     } catch (...) {
27508       {
27509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27510       };
27511     }
27512   }
27513
27514   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27515   return jresult;
27516 }
27517
27518
27519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27520   void * jresult ;
27521   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27522   Dali::FrameBuffer *arg2 = 0 ;
27523   Dali::FrameBuffer *result = 0 ;
27524
27525   arg1 = (Dali::FrameBuffer *)jarg1;
27526   arg2 = (Dali::FrameBuffer *)jarg2;
27527   if (!arg2) {
27528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27529     return 0;
27530   }
27531   {
27532     try {
27533       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27534     } catch (std::out_of_range& e) {
27535       {
27536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27537       };
27538     } catch (std::exception& e) {
27539       {
27540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27541       };
27542     } catch (Dali::DaliException e) {
27543       {
27544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27545       };
27546     } catch (...) {
27547       {
27548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27549       };
27550     }
27551   }
27552
27553   jresult = (void *)result;
27554   return jresult;
27555 }
27556
27557
27558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27559   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27560   Dali::Texture *arg2 = 0 ;
27561
27562   arg1 = (Dali::FrameBuffer *)jarg1;
27563   arg2 = (Dali::Texture *)jarg2;
27564   if (!arg2) {
27565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27566     return ;
27567   }
27568   {
27569     try {
27570       (arg1)->AttachColorTexture(*arg2);
27571     } catch (std::out_of_range& e) {
27572       {
27573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27574       };
27575     } catch (std::exception& e) {
27576       {
27577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27578       };
27579     } catch (Dali::DaliException e) {
27580       {
27581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27582       };
27583     } catch (...) {
27584       {
27585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27586       };
27587     }
27588   }
27589
27590 }
27591
27592
27593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27594   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27595   Dali::Texture *arg2 = 0 ;
27596   unsigned int arg3 ;
27597   unsigned int arg4 ;
27598
27599   arg1 = (Dali::FrameBuffer *)jarg1;
27600   arg2 = (Dali::Texture *)jarg2;
27601   if (!arg2) {
27602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27603     return ;
27604   }
27605   arg3 = (unsigned int)jarg3;
27606   arg4 = (unsigned int)jarg4;
27607   {
27608     try {
27609       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27610     } catch (std::out_of_range& e) {
27611       {
27612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27613       };
27614     } catch (std::exception& e) {
27615       {
27616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27617       };
27618     } catch (Dali::DaliException e) {
27619       {
27620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27621       };
27622     } catch (...) {
27623       {
27624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27625       };
27626     }
27627   }
27628
27629 }
27630
27631
27632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27633   void * jresult ;
27634   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27635   Dali::Texture result;
27636
27637   arg1 = (Dali::FrameBuffer *)jarg1;
27638   {
27639     try {
27640       result = (arg1)->GetColorTexture();
27641     } catch (std::out_of_range& e) {
27642       {
27643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27644       };
27645     } catch (std::exception& e) {
27646       {
27647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27648       };
27649     } catch (Dali::DaliException e) {
27650       {
27651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27652       };
27653     } catch (...) {
27654       {
27655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27656       };
27657     }
27658   }
27659
27660   jresult = new Dali::Texture((const Dali::Texture &)result);
27661   return jresult;
27662 }
27663
27664
27665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27666   void * jresult ;
27667   Dali::RenderTaskList *result = 0 ;
27668
27669   {
27670     try {
27671       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27672     } catch (std::out_of_range& e) {
27673       {
27674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27675       };
27676     } catch (std::exception& e) {
27677       {
27678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27679       };
27680     } catch (Dali::DaliException e) {
27681       {
27682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27683       };
27684     } catch (...) {
27685       {
27686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27687       };
27688     }
27689   }
27690
27691   jresult = (void *)result;
27692   return jresult;
27693 }
27694
27695
27696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27697   void * jresult ;
27698   Dali::BaseHandle arg1 ;
27699   Dali::BaseHandle *argp1 ;
27700   Dali::RenderTaskList result;
27701
27702   argp1 = (Dali::BaseHandle *)jarg1;
27703   if (!argp1) {
27704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27705     return 0;
27706   }
27707   arg1 = *argp1;
27708   {
27709     try {
27710       result = Dali::RenderTaskList::DownCast(arg1);
27711     } catch (std::out_of_range& e) {
27712       {
27713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27714       };
27715     } catch (std::exception& e) {
27716       {
27717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27718       };
27719     } catch (Dali::DaliException e) {
27720       {
27721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27722       };
27723     } catch (...) {
27724       {
27725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27726       };
27727     }
27728   }
27729
27730   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27731   return jresult;
27732 }
27733
27734
27735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27736   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27737
27738   arg1 = (Dali::RenderTaskList *)jarg1;
27739   {
27740     try {
27741       delete arg1;
27742     } catch (std::out_of_range& e) {
27743       {
27744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27745       };
27746     } catch (std::exception& e) {
27747       {
27748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27749       };
27750     } catch (Dali::DaliException e) {
27751       {
27752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27753       };
27754     } catch (...) {
27755       {
27756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27757       };
27758     }
27759   }
27760
27761 }
27762
27763
27764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27765   void * jresult ;
27766   Dali::RenderTaskList *arg1 = 0 ;
27767   Dali::RenderTaskList *result = 0 ;
27768
27769   arg1 = (Dali::RenderTaskList *)jarg1;
27770   if (!arg1) {
27771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27772     return 0;
27773   }
27774   {
27775     try {
27776       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27777     } catch (std::out_of_range& e) {
27778       {
27779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (std::exception& e) {
27782       {
27783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27784       };
27785     } catch (Dali::DaliException e) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27788       };
27789     } catch (...) {
27790       {
27791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27792       };
27793     }
27794   }
27795
27796   jresult = (void *)result;
27797   return jresult;
27798 }
27799
27800
27801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27802   void * jresult ;
27803   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27804   Dali::RenderTaskList *arg2 = 0 ;
27805   Dali::RenderTaskList *result = 0 ;
27806
27807   arg1 = (Dali::RenderTaskList *)jarg1;
27808   arg2 = (Dali::RenderTaskList *)jarg2;
27809   if (!arg2) {
27810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27811     return 0;
27812   }
27813   {
27814     try {
27815       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27816     } catch (std::out_of_range& e) {
27817       {
27818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27819       };
27820     } catch (std::exception& e) {
27821       {
27822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27823       };
27824     } catch (Dali::DaliException e) {
27825       {
27826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27827       };
27828     } catch (...) {
27829       {
27830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27831       };
27832     }
27833   }
27834
27835   jresult = (void *)result;
27836   return jresult;
27837 }
27838
27839
27840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27841   void * jresult ;
27842   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27843   Dali::RenderTask result;
27844
27845   arg1 = (Dali::RenderTaskList *)jarg1;
27846   {
27847     try {
27848       result = (arg1)->CreateTask();
27849     } catch (std::out_of_range& e) {
27850       {
27851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (std::exception& e) {
27854       {
27855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27856       };
27857     } catch (Dali::DaliException e) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27860       };
27861     } catch (...) {
27862       {
27863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27864       };
27865     }
27866   }
27867
27868   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27869   return jresult;
27870 }
27871
27872
27873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27874   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27875   Dali::RenderTask arg2 ;
27876   Dali::RenderTask *argp2 ;
27877
27878   arg1 = (Dali::RenderTaskList *)jarg1;
27879   argp2 = (Dali::RenderTask *)jarg2;
27880   if (!argp2) {
27881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27882     return ;
27883   }
27884   arg2 = *argp2;
27885   {
27886     try {
27887       (arg1)->RemoveTask(arg2);
27888     } catch (std::out_of_range& e) {
27889       {
27890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27891       };
27892     } catch (std::exception& e) {
27893       {
27894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27895       };
27896     } catch (Dali::DaliException e) {
27897       {
27898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27899       };
27900     } catch (...) {
27901       {
27902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27903       };
27904     }
27905   }
27906
27907 }
27908
27909
27910 //// ===============================================end part 1 =================
27911
27912 //// ========================= part 2 ===============================
27913
27914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27915   unsigned int jresult ;
27916   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27917   unsigned int result;
27918
27919   arg1 = (Dali::RenderTaskList *)jarg1;
27920   {
27921     try {
27922       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27923     } catch (std::out_of_range& e) {
27924       {
27925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (std::exception& e) {
27928       {
27929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27930       };
27931     } catch (Dali::DaliException e) {
27932       {
27933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27934       };
27935     } catch (...) {
27936       {
27937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27938       };
27939     }
27940   }
27941
27942   jresult = result;
27943   return jresult;
27944 }
27945
27946
27947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27948   void * jresult ;
27949   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27950   unsigned int arg2 ;
27951   Dali::RenderTask result;
27952
27953   arg1 = (Dali::RenderTaskList *)jarg1;
27954   arg2 = (unsigned int)jarg2;
27955   {
27956     try {
27957       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27958     } catch (std::out_of_range& e) {
27959       {
27960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27961       };
27962     } catch (std::exception& e) {
27963       {
27964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27965       };
27966     } catch (Dali::DaliException e) {
27967       {
27968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27969       };
27970     } catch (...) {
27971       {
27972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27973       };
27974     }
27975   }
27976
27977   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27978   return jresult;
27979 }
27980
27981
27982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27983   int jresult ;
27984   int result;
27985
27986   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27987   jresult = (int)result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27993   int jresult ;
27994   int result;
27995
27996   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27997   jresult = (int)result;
27998   return jresult;
27999 }
28000
28001
28002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28003   int jresult ;
28004   int result;
28005
28006   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28007   jresult = (int)result;
28008   return jresult;
28009 }
28010
28011
28012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28013   int jresult ;
28014   int result;
28015
28016   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28017   jresult = (int)result;
28018   return jresult;
28019 }
28020
28021
28022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28023   void * jresult ;
28024   Dali::RenderTask::Property *result = 0 ;
28025
28026   {
28027     try {
28028       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28029     } catch (std::out_of_range& e) {
28030       {
28031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28032       };
28033     } catch (std::exception& e) {
28034       {
28035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28036       };
28037     } catch (Dali::DaliException e) {
28038       {
28039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28040       };
28041     } catch (...) {
28042       {
28043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28044       };
28045     }
28046   }
28047
28048   jresult = (void *)result;
28049   return jresult;
28050 }
28051
28052
28053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28054   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28055
28056   arg1 = (Dali::RenderTask::Property *)jarg1;
28057   {
28058     try {
28059       delete arg1;
28060     } catch (std::out_of_range& e) {
28061       {
28062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28063       };
28064     } catch (std::exception& e) {
28065       {
28066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28067       };
28068     } catch (Dali::DaliException e) {
28069       {
28070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28071       };
28072     } catch (...) {
28073       {
28074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28075       };
28076     }
28077   }
28078
28079 }
28080
28081
28082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28083   void * jresult ;
28084   bool (*result)(Dali::Vector2 &) = 0 ;
28085
28086   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28087   jresult = (void *)result;
28088   return jresult;
28089 }
28090
28091
28092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28093   void * jresult ;
28094   bool (*result)(Dali::Vector2 &) = 0 ;
28095
28096   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28097   jresult = (void *)result;
28098   return jresult;
28099 }
28100
28101
28102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28103   unsigned int jresult ;
28104   bool result;
28105
28106   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28107   jresult = result;
28108   return jresult;
28109 }
28110
28111
28112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28113   unsigned int jresult ;
28114   bool result;
28115
28116   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28117   jresult = result;
28118   return jresult;
28119 }
28120
28121
28122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28123   void * jresult ;
28124   Dali::Vector4 *result = 0 ;
28125
28126   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28127   jresult = (void *)result;
28128   return jresult;
28129 }
28130
28131
28132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28133   unsigned int jresult ;
28134   bool result;
28135
28136   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28137   jresult = result;
28138   return jresult;
28139 }
28140
28141
28142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28143   unsigned int jresult ;
28144   bool result;
28145
28146   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28147   jresult = result;
28148   return jresult;
28149 }
28150
28151
28152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28153   unsigned int jresult ;
28154   unsigned int result;
28155
28156   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28157   jresult = result;
28158   return jresult;
28159 }
28160
28161
28162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28163   void * jresult ;
28164   Dali::RenderTask *result = 0 ;
28165
28166   {
28167     try {
28168       result = (Dali::RenderTask *)new Dali::RenderTask();
28169     } catch (std::out_of_range& e) {
28170       {
28171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28172       };
28173     } catch (std::exception& e) {
28174       {
28175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28176       };
28177     } catch (Dali::DaliException e) {
28178       {
28179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28180       };
28181     } catch (...) {
28182       {
28183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28184       };
28185     }
28186   }
28187
28188   jresult = (void *)result;
28189   return jresult;
28190 }
28191
28192
28193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28194   void * jresult ;
28195   Dali::BaseHandle arg1 ;
28196   Dali::BaseHandle *argp1 ;
28197   Dali::RenderTask result;
28198
28199   argp1 = (Dali::BaseHandle *)jarg1;
28200   if (!argp1) {
28201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28202     return 0;
28203   }
28204   arg1 = *argp1;
28205   {
28206     try {
28207       result = Dali::RenderTask::DownCast(arg1);
28208     } catch (std::out_of_range& e) {
28209       {
28210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28211       };
28212     } catch (std::exception& e) {
28213       {
28214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28215       };
28216     } catch (Dali::DaliException e) {
28217       {
28218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28219       };
28220     } catch (...) {
28221       {
28222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28223       };
28224     }
28225   }
28226
28227   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28228   return jresult;
28229 }
28230
28231
28232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28233   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28234
28235   arg1 = (Dali::RenderTask *)jarg1;
28236   {
28237     try {
28238       delete arg1;
28239     } catch (std::out_of_range& e) {
28240       {
28241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28242       };
28243     } catch (std::exception& e) {
28244       {
28245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28246       };
28247     } catch (Dali::DaliException e) {
28248       {
28249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28250       };
28251     } catch (...) {
28252       {
28253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28254       };
28255     }
28256   }
28257
28258 }
28259
28260
28261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28262   void * jresult ;
28263   Dali::RenderTask *arg1 = 0 ;
28264   Dali::RenderTask *result = 0 ;
28265
28266   arg1 = (Dali::RenderTask *)jarg1;
28267   if (!arg1) {
28268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28269     return 0;
28270   }
28271   {
28272     try {
28273       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28274     } catch (std::out_of_range& e) {
28275       {
28276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28277       };
28278     } catch (std::exception& e) {
28279       {
28280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28281       };
28282     } catch (Dali::DaliException e) {
28283       {
28284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28285       };
28286     } catch (...) {
28287       {
28288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28289       };
28290     }
28291   }
28292
28293   jresult = (void *)result;
28294   return jresult;
28295 }
28296
28297
28298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28299   void * jresult ;
28300   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28301   Dali::RenderTask *arg2 = 0 ;
28302   Dali::RenderTask *result = 0 ;
28303
28304   arg1 = (Dali::RenderTask *)jarg1;
28305   arg2 = (Dali::RenderTask *)jarg2;
28306   if (!arg2) {
28307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28308     return 0;
28309   }
28310   {
28311     try {
28312       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28313     } catch (std::out_of_range& e) {
28314       {
28315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28316       };
28317     } catch (std::exception& e) {
28318       {
28319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28320       };
28321     } catch (Dali::DaliException e) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28324       };
28325     } catch (...) {
28326       {
28327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28328       };
28329     }
28330   }
28331
28332   jresult = (void *)result;
28333   return jresult;
28334 }
28335
28336
28337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28338   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28339   Dali::Actor arg2 ;
28340   Dali::Actor *argp2 ;
28341
28342   arg1 = (Dali::RenderTask *)jarg1;
28343   argp2 = (Dali::Actor *)jarg2;
28344   if (!argp2) {
28345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28346     return ;
28347   }
28348   arg2 = *argp2;
28349   {
28350     try {
28351       (arg1)->SetSourceActor(arg2);
28352     } catch (std::out_of_range& e) {
28353       {
28354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28355       };
28356     } catch (std::exception& e) {
28357       {
28358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28359       };
28360     } catch (Dali::DaliException e) {
28361       {
28362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28363       };
28364     } catch (...) {
28365       {
28366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28367       };
28368     }
28369   }
28370
28371 }
28372
28373
28374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28375   void * jresult ;
28376   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28377   Dali::Actor result;
28378
28379   arg1 = (Dali::RenderTask *)jarg1;
28380   {
28381     try {
28382       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28383     } catch (std::out_of_range& e) {
28384       {
28385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28386       };
28387     } catch (std::exception& e) {
28388       {
28389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28390       };
28391     } catch (Dali::DaliException e) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28394       };
28395     } catch (...) {
28396       {
28397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28398       };
28399     }
28400   }
28401
28402   jresult = new Dali::Actor((const Dali::Actor &)result);
28403   return jresult;
28404 }
28405
28406
28407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28408   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28409   bool arg2 ;
28410
28411   arg1 = (Dali::RenderTask *)jarg1;
28412   arg2 = jarg2 ? true : false;
28413   {
28414     try {
28415       (arg1)->SetExclusive(arg2);
28416     } catch (std::out_of_range& e) {
28417       {
28418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28419       };
28420     } catch (std::exception& e) {
28421       {
28422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28423       };
28424     } catch (Dali::DaliException e) {
28425       {
28426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28427       };
28428     } catch (...) {
28429       {
28430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28431       };
28432     }
28433   }
28434
28435 }
28436
28437
28438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28439   unsigned int jresult ;
28440   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28441   bool result;
28442
28443   arg1 = (Dali::RenderTask *)jarg1;
28444   {
28445     try {
28446       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28447     } catch (std::out_of_range& e) {
28448       {
28449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28450       };
28451     } catch (std::exception& e) {
28452       {
28453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28454       };
28455     } catch (Dali::DaliException e) {
28456       {
28457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28458       };
28459     } catch (...) {
28460       {
28461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28462       };
28463     }
28464   }
28465
28466   jresult = result;
28467   return jresult;
28468 }
28469
28470
28471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28473   bool arg2 ;
28474
28475   arg1 = (Dali::RenderTask *)jarg1;
28476   arg2 = jarg2 ? true : false;
28477   {
28478     try {
28479       (arg1)->SetInputEnabled(arg2);
28480     } catch (std::out_of_range& e) {
28481       {
28482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28483       };
28484     } catch (std::exception& e) {
28485       {
28486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28487       };
28488     } catch (Dali::DaliException e) {
28489       {
28490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28491       };
28492     } catch (...) {
28493       {
28494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28495       };
28496     }
28497   }
28498
28499 }
28500
28501
28502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28503   unsigned int jresult ;
28504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28505   bool result;
28506
28507   arg1 = (Dali::RenderTask *)jarg1;
28508   {
28509     try {
28510       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28511     } catch (std::out_of_range& e) {
28512       {
28513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28514       };
28515     } catch (std::exception& e) {
28516       {
28517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28518       };
28519     } catch (Dali::DaliException e) {
28520       {
28521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28522       };
28523     } catch (...) {
28524       {
28525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28526       };
28527     }
28528   }
28529
28530   jresult = result;
28531   return jresult;
28532 }
28533
28534
28535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28536   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28537   Dali::CameraActor arg2 ;
28538   Dali::CameraActor *argp2 ;
28539
28540   arg1 = (Dali::RenderTask *)jarg1;
28541   argp2 = (Dali::CameraActor *)jarg2;
28542   if (!argp2) {
28543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28544     return ;
28545   }
28546   arg2 = *argp2;
28547   {
28548     try {
28549       (arg1)->SetCameraActor(arg2);
28550     } catch (std::out_of_range& e) {
28551       {
28552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28553       };
28554     } catch (std::exception& e) {
28555       {
28556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28557       };
28558     } catch (Dali::DaliException e) {
28559       {
28560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28561       };
28562     } catch (...) {
28563       {
28564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28565       };
28566     }
28567   }
28568
28569 }
28570
28571
28572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28573   void * jresult ;
28574   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28575   Dali::CameraActor result;
28576
28577   arg1 = (Dali::RenderTask *)jarg1;
28578   {
28579     try {
28580       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28581     } catch (std::out_of_range& e) {
28582       {
28583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28584       };
28585     } catch (std::exception& e) {
28586       {
28587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28588       };
28589     } catch (Dali::DaliException e) {
28590       {
28591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28592       };
28593     } catch (...) {
28594       {
28595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28596       };
28597     }
28598   }
28599
28600   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28601   return jresult;
28602 }
28603
28604
28605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28606   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28607   Dali::FrameBufferImage arg2 ;
28608   Dali::FrameBufferImage *argp2 ;
28609
28610   arg1 = (Dali::RenderTask *)jarg1;
28611   argp2 = (Dali::FrameBufferImage *)jarg2;
28612   if (!argp2) {
28613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28614     return ;
28615   }
28616   arg2 = *argp2;
28617   {
28618     try {
28619       (arg1)->SetTargetFrameBuffer(arg2);
28620     } catch (std::out_of_range& e) {
28621       {
28622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28623       };
28624     } catch (std::exception& e) {
28625       {
28626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28627       };
28628     } catch (Dali::DaliException e) {
28629       {
28630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28631       };
28632     } catch (...) {
28633       {
28634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28635       };
28636     }
28637   }
28638
28639 }
28640
28641
28642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28643   void * jresult ;
28644   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28645   Dali::FrameBufferImage result;
28646
28647   arg1 = (Dali::RenderTask *)jarg1;
28648   {
28649     try {
28650       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28651     } catch (std::out_of_range& e) {
28652       {
28653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28654       };
28655     } catch (std::exception& e) {
28656       {
28657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28658       };
28659     } catch (Dali::DaliException e) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28662       };
28663     } catch (...) {
28664       {
28665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28666       };
28667     }
28668   }
28669
28670   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28671   return jresult;
28672 }
28673
28674
28675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28676   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28677   Dali::FrameBuffer arg2 ;
28678   Dali::FrameBuffer *argp2 ;
28679
28680   arg1 = (Dali::RenderTask *)jarg1;
28681   argp2 = (Dali::FrameBuffer *)jarg2;
28682   if (!argp2) {
28683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28684     return ;
28685   }
28686   arg2 = *argp2;
28687   {
28688     try {
28689       (arg1)->SetFrameBuffer(arg2);
28690     } catch (std::out_of_range& e) {
28691       {
28692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28693       };
28694     } catch (std::exception& e) {
28695       {
28696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28697       };
28698     } catch (Dali::DaliException e) {
28699       {
28700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28701       };
28702     } catch (...) {
28703       {
28704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28705       };
28706     }
28707   }
28708
28709 }
28710
28711
28712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28713   void * jresult ;
28714   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28715   Dali::FrameBuffer result;
28716
28717   arg1 = (Dali::RenderTask *)jarg1;
28718   {
28719     try {
28720       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28721     } catch (std::out_of_range& e) {
28722       {
28723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28724       };
28725     } catch (std::exception& e) {
28726       {
28727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28728       };
28729     } catch (Dali::DaliException e) {
28730       {
28731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28732       };
28733     } catch (...) {
28734       {
28735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28736       };
28737     }
28738   }
28739
28740   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28741   return jresult;
28742 }
28743
28744
28745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28746   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28747   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28748
28749   arg1 = (Dali::RenderTask *)jarg1;
28750   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28751   {
28752     try {
28753       (arg1)->SetScreenToFrameBufferFunction(arg2);
28754     } catch (std::out_of_range& e) {
28755       {
28756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28757       };
28758     } catch (std::exception& e) {
28759       {
28760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28761       };
28762     } catch (Dali::DaliException e) {
28763       {
28764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28765       };
28766     } catch (...) {
28767       {
28768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28769       };
28770     }
28771   }
28772
28773 }
28774
28775
28776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28777   void * jresult ;
28778   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28779   Dali::RenderTask::ScreenToFrameBufferFunction result;
28780
28781   arg1 = (Dali::RenderTask *)jarg1;
28782   {
28783     try {
28784       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28785     } catch (std::out_of_range& e) {
28786       {
28787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28788       };
28789     } catch (std::exception& e) {
28790       {
28791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28792       };
28793     } catch (Dali::DaliException e) {
28794       {
28795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28796       };
28797     } catch (...) {
28798       {
28799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28800       };
28801     }
28802   }
28803
28804   jresult = (void *)result;
28805   return jresult;
28806 }
28807
28808
28809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28810   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28811   Dali::Actor arg2 ;
28812   Dali::Actor *argp2 ;
28813
28814   arg1 = (Dali::RenderTask *)jarg1;
28815   argp2 = (Dali::Actor *)jarg2;
28816   if (!argp2) {
28817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28818     return ;
28819   }
28820   arg2 = *argp2;
28821   {
28822     try {
28823       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28824     } catch (std::out_of_range& e) {
28825       {
28826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28827       };
28828     } catch (std::exception& e) {
28829       {
28830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28831       };
28832     } catch (Dali::DaliException e) {
28833       {
28834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28835       };
28836     } catch (...) {
28837       {
28838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28839       };
28840     }
28841   }
28842
28843 }
28844
28845
28846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28847   void * jresult ;
28848   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28849   Dali::Actor result;
28850
28851   arg1 = (Dali::RenderTask *)jarg1;
28852   {
28853     try {
28854       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28855     } catch (std::out_of_range& e) {
28856       {
28857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28858       };
28859     } catch (std::exception& e) {
28860       {
28861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28862       };
28863     } catch (Dali::DaliException e) {
28864       {
28865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28866       };
28867     } catch (...) {
28868       {
28869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28870       };
28871     }
28872   }
28873
28874   jresult = new Dali::Actor((const Dali::Actor &)result);
28875   return jresult;
28876 }
28877
28878
28879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28880   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28881   Dali::Vector2 arg2 ;
28882   Dali::Vector2 *argp2 ;
28883
28884   arg1 = (Dali::RenderTask *)jarg1;
28885   argp2 = (Dali::Vector2 *)jarg2;
28886   if (!argp2) {
28887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28888     return ;
28889   }
28890   arg2 = *argp2;
28891   {
28892     try {
28893       (arg1)->SetViewportPosition(arg2);
28894     } catch (std::out_of_range& e) {
28895       {
28896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28897       };
28898     } catch (std::exception& e) {
28899       {
28900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28901       };
28902     } catch (Dali::DaliException e) {
28903       {
28904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28905       };
28906     } catch (...) {
28907       {
28908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28909       };
28910     }
28911   }
28912
28913 }
28914
28915
28916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28917   void * jresult ;
28918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28919   Dali::Vector2 result;
28920
28921   arg1 = (Dali::RenderTask *)jarg1;
28922   {
28923     try {
28924       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28925     } catch (std::out_of_range& e) {
28926       {
28927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28928       };
28929     } catch (std::exception& e) {
28930       {
28931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28932       };
28933     } catch (Dali::DaliException e) {
28934       {
28935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28936       };
28937     } catch (...) {
28938       {
28939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28940       };
28941     }
28942   }
28943
28944   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28945   return jresult;
28946 }
28947
28948
28949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28951   Dali::Vector2 arg2 ;
28952   Dali::Vector2 *argp2 ;
28953
28954   arg1 = (Dali::RenderTask *)jarg1;
28955   argp2 = (Dali::Vector2 *)jarg2;
28956   if (!argp2) {
28957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28958     return ;
28959   }
28960   arg2 = *argp2;
28961   {
28962     try {
28963       (arg1)->SetViewportSize(arg2);
28964     } catch (std::out_of_range& e) {
28965       {
28966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28967       };
28968     } catch (std::exception& e) {
28969       {
28970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28971       };
28972     } catch (Dali::DaliException e) {
28973       {
28974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28975       };
28976     } catch (...) {
28977       {
28978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28979       };
28980     }
28981   }
28982
28983 }
28984
28985
28986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28987   void * jresult ;
28988   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28989   Dali::Vector2 result;
28990
28991   arg1 = (Dali::RenderTask *)jarg1;
28992   {
28993     try {
28994       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28995     } catch (std::out_of_range& e) {
28996       {
28997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28998       };
28999     } catch (std::exception& e) {
29000       {
29001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29002       };
29003     } catch (Dali::DaliException e) {
29004       {
29005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29006       };
29007     } catch (...) {
29008       {
29009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29010       };
29011     }
29012   }
29013
29014   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29015   return jresult;
29016 }
29017
29018
29019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29020   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29021   Dali::Viewport arg2 ;
29022   Dali::Viewport *argp2 ;
29023
29024   arg1 = (Dali::RenderTask *)jarg1;
29025   argp2 = (Dali::Viewport *)jarg2;
29026   if (!argp2) {
29027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29028     return ;
29029   }
29030   arg2 = *argp2;
29031   {
29032     try {
29033       (arg1)->SetViewport(arg2);
29034     } catch (std::out_of_range& e) {
29035       {
29036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29037       };
29038     } catch (std::exception& e) {
29039       {
29040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29041       };
29042     } catch (Dali::DaliException e) {
29043       {
29044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29045       };
29046     } catch (...) {
29047       {
29048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29049       };
29050     }
29051   }
29052
29053 }
29054
29055
29056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29057   void * jresult ;
29058   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29059   Dali::Viewport result;
29060
29061   arg1 = (Dali::RenderTask *)jarg1;
29062   {
29063     try {
29064       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29065     } catch (std::out_of_range& e) {
29066       {
29067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29068       };
29069     } catch (std::exception& e) {
29070       {
29071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29072       };
29073     } catch (Dali::DaliException e) {
29074       {
29075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29076       };
29077     } catch (...) {
29078       {
29079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29080       };
29081     }
29082   }
29083
29084   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29085   return jresult;
29086 }
29087
29088
29089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29090   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29091   Dali::Vector4 *arg2 = 0 ;
29092
29093   arg1 = (Dali::RenderTask *)jarg1;
29094   arg2 = (Dali::Vector4 *)jarg2;
29095   if (!arg2) {
29096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29097     return ;
29098   }
29099   {
29100     try {
29101       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29102     } catch (std::out_of_range& e) {
29103       {
29104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29105       };
29106     } catch (std::exception& e) {
29107       {
29108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29109       };
29110     } catch (Dali::DaliException e) {
29111       {
29112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29113       };
29114     } catch (...) {
29115       {
29116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29117       };
29118     }
29119   }
29120
29121 }
29122
29123
29124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29125   void * jresult ;
29126   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29127   Dali::Vector4 result;
29128
29129   arg1 = (Dali::RenderTask *)jarg1;
29130   {
29131     try {
29132       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29133     } catch (std::out_of_range& e) {
29134       {
29135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29136       };
29137     } catch (std::exception& e) {
29138       {
29139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29140       };
29141     } catch (Dali::DaliException e) {
29142       {
29143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29144       };
29145     } catch (...) {
29146       {
29147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29148       };
29149     }
29150   }
29151
29152   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29153   return jresult;
29154 }
29155
29156
29157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29158   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29159   bool arg2 ;
29160
29161   arg1 = (Dali::RenderTask *)jarg1;
29162   arg2 = jarg2 ? true : false;
29163   {
29164     try {
29165       (arg1)->SetClearEnabled(arg2);
29166     } catch (std::out_of_range& e) {
29167       {
29168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29169       };
29170     } catch (std::exception& e) {
29171       {
29172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29173       };
29174     } catch (Dali::DaliException e) {
29175       {
29176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29177       };
29178     } catch (...) {
29179       {
29180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29181       };
29182     }
29183   }
29184
29185 }
29186
29187
29188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29189   unsigned int jresult ;
29190   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29191   bool result;
29192
29193   arg1 = (Dali::RenderTask *)jarg1;
29194   {
29195     try {
29196       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29197     } catch (std::out_of_range& e) {
29198       {
29199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29200       };
29201     } catch (std::exception& e) {
29202       {
29203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29204       };
29205     } catch (Dali::DaliException e) {
29206       {
29207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29208       };
29209     } catch (...) {
29210       {
29211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29212       };
29213     }
29214   }
29215
29216   jresult = result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29222   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29223   bool arg2 ;
29224
29225   arg1 = (Dali::RenderTask *)jarg1;
29226   arg2 = jarg2 ? true : false;
29227   {
29228     try {
29229       (arg1)->SetCullMode(arg2);
29230     } catch (std::out_of_range& e) {
29231       {
29232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29233       };
29234     } catch (std::exception& e) {
29235       {
29236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29237       };
29238     } catch (Dali::DaliException e) {
29239       {
29240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29241       };
29242     } catch (...) {
29243       {
29244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29245       };
29246     }
29247   }
29248
29249 }
29250
29251
29252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29253   unsigned int jresult ;
29254   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29255   bool result;
29256
29257   arg1 = (Dali::RenderTask *)jarg1;
29258   {
29259     try {
29260       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29261     } catch (std::out_of_range& e) {
29262       {
29263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29264       };
29265     } catch (std::exception& e) {
29266       {
29267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29268       };
29269     } catch (Dali::DaliException e) {
29270       {
29271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29272       };
29273     } catch (...) {
29274       {
29275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29276       };
29277     }
29278   }
29279
29280   jresult = result;
29281   return jresult;
29282 }
29283
29284
29285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29286   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29287   unsigned int arg2 ;
29288
29289   arg1 = (Dali::RenderTask *)jarg1;
29290   arg2 = (unsigned int)jarg2;
29291   {
29292     try {
29293       (arg1)->SetRefreshRate(arg2);
29294     } catch (std::out_of_range& e) {
29295       {
29296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29297       };
29298     } catch (std::exception& e) {
29299       {
29300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29301       };
29302     } catch (Dali::DaliException e) {
29303       {
29304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29305       };
29306     } catch (...) {
29307       {
29308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29309       };
29310     }
29311   }
29312
29313 }
29314
29315
29316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29317   unsigned int jresult ;
29318   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29319   unsigned int result;
29320
29321   arg1 = (Dali::RenderTask *)jarg1;
29322   {
29323     try {
29324       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29325     } catch (std::out_of_range& e) {
29326       {
29327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29328       };
29329     } catch (std::exception& e) {
29330       {
29331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29332       };
29333     } catch (Dali::DaliException e) {
29334       {
29335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29336       };
29337     } catch (...) {
29338       {
29339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29340       };
29341     }
29342   }
29343
29344   jresult = result;
29345   return jresult;
29346 }
29347
29348
29349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29350   unsigned int jresult ;
29351   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29352   Dali::Vector3 *arg2 = 0 ;
29353   float *arg3 = 0 ;
29354   float *arg4 = 0 ;
29355   bool result;
29356
29357   arg1 = (Dali::RenderTask *)jarg1;
29358   arg2 = (Dali::Vector3 *)jarg2;
29359   if (!arg2) {
29360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29361     return 0;
29362   }
29363   arg3 = (float *)jarg3;
29364   arg4 = (float *)jarg4;
29365   {
29366     try {
29367       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29368     } catch (std::out_of_range& e) {
29369       {
29370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29371       };
29372     } catch (std::exception& e) {
29373       {
29374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29375       };
29376     } catch (Dali::DaliException e) {
29377       {
29378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29379       };
29380     } catch (...) {
29381       {
29382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29383       };
29384     }
29385   }
29386
29387   jresult = result;
29388   return jresult;
29389 }
29390
29391
29392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29393   unsigned int jresult ;
29394   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29395   Dali::Actor arg2 ;
29396   float arg3 ;
29397   float arg4 ;
29398   float *arg5 = 0 ;
29399   float *arg6 = 0 ;
29400   Dali::Actor *argp2 ;
29401   bool result;
29402
29403   arg1 = (Dali::RenderTask *)jarg1;
29404   argp2 = (Dali::Actor *)jarg2;
29405   if (!argp2) {
29406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29407     return 0;
29408   }
29409   arg2 = *argp2;
29410   arg3 = (float)jarg3;
29411   arg4 = (float)jarg4;
29412   arg5 = (float *)jarg5;
29413   arg6 = (float *)jarg6;
29414   {
29415     try {
29416       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29417     } catch (std::out_of_range& e) {
29418       {
29419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29420       };
29421     } catch (std::exception& e) {
29422       {
29423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29424       };
29425     } catch (Dali::DaliException e) {
29426       {
29427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29428       };
29429     } catch (...) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29432       };
29433     }
29434   }
29435
29436   jresult = result;
29437   return jresult;
29438 }
29439
29440
29441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29442   void * jresult ;
29443   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29444   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29445
29446   arg1 = (Dali::RenderTask *)jarg1;
29447   {
29448     try {
29449       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29450     } catch (std::out_of_range& e) {
29451       {
29452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29453       };
29454     } catch (std::exception& e) {
29455       {
29456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29457       };
29458     } catch (Dali::DaliException e) {
29459       {
29460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29461       };
29462     } catch (...) {
29463       {
29464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29465       };
29466     }
29467   }
29468
29469   jresult = (void *)result;
29470   return jresult;
29471 }
29472
29473
29474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29475   void * jresult ;
29476   int arg1 ;
29477   Dali::TouchPoint::State arg2 ;
29478   float arg3 ;
29479   float arg4 ;
29480   Dali::TouchPoint *result = 0 ;
29481
29482   arg1 = (int)jarg1;
29483   arg2 = (Dali::TouchPoint::State)jarg2;
29484   arg3 = (float)jarg3;
29485   arg4 = (float)jarg4;
29486   {
29487     try {
29488       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29489     } catch (std::out_of_range& e) {
29490       {
29491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29492       };
29493     } catch (std::exception& e) {
29494       {
29495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29496       };
29497     } catch (Dali::DaliException e) {
29498       {
29499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29500       };
29501     } catch (...) {
29502       {
29503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29504       };
29505     }
29506   }
29507
29508   jresult = (void *)result;
29509   return jresult;
29510 }
29511
29512
29513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29514   void * jresult ;
29515   int arg1 ;
29516   Dali::TouchPoint::State arg2 ;
29517   float arg3 ;
29518   float arg4 ;
29519   float arg5 ;
29520   float arg6 ;
29521   Dali::TouchPoint *result = 0 ;
29522
29523   arg1 = (int)jarg1;
29524   arg2 = (Dali::TouchPoint::State)jarg2;
29525   arg3 = (float)jarg3;
29526   arg4 = (float)jarg4;
29527   arg5 = (float)jarg5;
29528   arg6 = (float)jarg6;
29529   {
29530     try {
29531       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29532     } catch (std::out_of_range& e) {
29533       {
29534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (std::exception& e) {
29537       {
29538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29539       };
29540     } catch (Dali::DaliException e) {
29541       {
29542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29543       };
29544     } catch (...) {
29545       {
29546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29547       };
29548     }
29549   }
29550
29551   jresult = (void *)result;
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29557   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29558
29559   arg1 = (Dali::TouchPoint *)jarg1;
29560   {
29561     try {
29562       delete arg1;
29563     } catch (std::out_of_range& e) {
29564       {
29565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29566       };
29567     } catch (std::exception& e) {
29568       {
29569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29570       };
29571     } catch (Dali::DaliException e) {
29572       {
29573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29574       };
29575     } catch (...) {
29576       {
29577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29578       };
29579     }
29580   }
29581
29582 }
29583
29584
29585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29586   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29587   int arg2 ;
29588
29589   arg1 = (Dali::TouchPoint *)jarg1;
29590   arg2 = (int)jarg2;
29591   if (arg1) (arg1)->deviceId = arg2;
29592 }
29593
29594
29595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29596   int jresult ;
29597   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29598   int result;
29599
29600   arg1 = (Dali::TouchPoint *)jarg1;
29601   result = (int) ((arg1)->deviceId);
29602   jresult = result;
29603   return jresult;
29604 }
29605
29606
29607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29608   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29609   Dali::TouchPoint::State arg2 ;
29610
29611   arg1 = (Dali::TouchPoint *)jarg1;
29612   arg2 = (Dali::TouchPoint::State)jarg2;
29613   if (arg1) (arg1)->state = arg2;
29614 }
29615
29616
29617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29618   int jresult ;
29619   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29620   Dali::TouchPoint::State result;
29621
29622   arg1 = (Dali::TouchPoint *)jarg1;
29623   result = (Dali::TouchPoint::State) ((arg1)->state);
29624   jresult = (int)result;
29625   return jresult;
29626 }
29627
29628
29629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29630   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29631   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29632
29633   arg1 = (Dali::TouchPoint *)jarg1;
29634   arg2 = (Dali::Actor *)jarg2;
29635   if (arg1) (arg1)->hitActor = *arg2;
29636 }
29637
29638
29639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29640   void * jresult ;
29641   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29642   Dali::Actor *result = 0 ;
29643
29644   arg1 = (Dali::TouchPoint *)jarg1;
29645   result = (Dali::Actor *)& ((arg1)->hitActor);
29646   jresult = (void *)result;
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29652   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29653   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29654
29655   arg1 = (Dali::TouchPoint *)jarg1;
29656   arg2 = (Dali::Vector2 *)jarg2;
29657   if (arg1) (arg1)->local = *arg2;
29658 }
29659
29660
29661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29662   void * jresult ;
29663   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29664   Dali::Vector2 *result = 0 ;
29665
29666   arg1 = (Dali::TouchPoint *)jarg1;
29667   result = (Dali::Vector2 *)& ((arg1)->local);
29668   jresult = (void *)result;
29669   return jresult;
29670 }
29671
29672
29673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29674   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29675   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29676
29677   arg1 = (Dali::TouchPoint *)jarg1;
29678   arg2 = (Dali::Vector2 *)jarg2;
29679   if (arg1) (arg1)->screen = *arg2;
29680 }
29681
29682
29683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29684   void * jresult ;
29685   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29686   Dali::Vector2 *result = 0 ;
29687
29688   arg1 = (Dali::TouchPoint *)jarg1;
29689   result = (Dali::Vector2 *)& ((arg1)->screen);
29690   jresult = (void *)result;
29691   return jresult;
29692 }
29693
29694
29695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29696   void * jresult ;
29697   Dali::TouchData *result = 0 ;
29698
29699   {
29700     try {
29701       result = (Dali::TouchData *)new Dali::TouchData();
29702     } catch (std::out_of_range& e) {
29703       {
29704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29705       };
29706     } catch (std::exception& e) {
29707       {
29708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29709       };
29710     } catch (Dali::DaliException e) {
29711       {
29712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29713       };
29714     } catch (...) {
29715       {
29716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29717       };
29718     }
29719   }
29720
29721   jresult = (void *)result;
29722   return jresult;
29723 }
29724
29725
29726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29727   void * jresult ;
29728   Dali::TouchData *arg1 = 0 ;
29729   Dali::TouchData *result = 0 ;
29730
29731   arg1 = (Dali::TouchData *)jarg1;
29732   if (!arg1) {
29733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29734     return 0;
29735   }
29736   {
29737     try {
29738       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29739     } catch (std::out_of_range& e) {
29740       {
29741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29742       };
29743     } catch (std::exception& e) {
29744       {
29745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29746       };
29747     } catch (Dali::DaliException e) {
29748       {
29749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29750       };
29751     } catch (...) {
29752       {
29753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29754       };
29755     }
29756   }
29757
29758   jresult = (void *)result;
29759   return jresult;
29760 }
29761
29762
29763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29764   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29765
29766   arg1 = (Dali::TouchData *)jarg1;
29767   {
29768     try {
29769       delete arg1;
29770     } catch (std::out_of_range& e) {
29771       {
29772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29773       };
29774     } catch (std::exception& e) {
29775       {
29776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29777       };
29778     } catch (Dali::DaliException e) {
29779       {
29780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29781       };
29782     } catch (...) {
29783       {
29784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29785       };
29786     }
29787   }
29788
29789 }
29790
29791
29792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29793   void * jresult ;
29794   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29795   Dali::TouchData *arg2 = 0 ;
29796   Dali::TouchData *result = 0 ;
29797
29798   arg1 = (Dali::TouchData *)jarg1;
29799   arg2 = (Dali::TouchData *)jarg2;
29800   if (!arg2) {
29801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29802     return 0;
29803   }
29804   {
29805     try {
29806       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29807     } catch (std::out_of_range& e) {
29808       {
29809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29810       };
29811     } catch (std::exception& e) {
29812       {
29813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29814       };
29815     } catch (Dali::DaliException e) {
29816       {
29817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29818       };
29819     } catch (...) {
29820       {
29821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29822       };
29823     }
29824   }
29825
29826   jresult = (void *)result;
29827   return jresult;
29828 }
29829
29830
29831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29832   unsigned long jresult ;
29833   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29834   unsigned long result;
29835
29836   arg1 = (Dali::TouchData *)jarg1;
29837   {
29838     try {
29839       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29840     } catch (std::out_of_range& e) {
29841       {
29842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29843       };
29844     } catch (std::exception& e) {
29845       {
29846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29847       };
29848     } catch (Dali::DaliException e) {
29849       {
29850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29851       };
29852     } catch (...) {
29853       {
29854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29855       };
29856     }
29857   }
29858
29859   jresult = (unsigned long)result;
29860   return jresult;
29861 }
29862
29863
29864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29865   unsigned long jresult ;
29866   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29867   std::size_t result;
29868
29869   arg1 = (Dali::TouchData *)jarg1;
29870   {
29871     try {
29872       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29873     } catch (std::out_of_range& e) {
29874       {
29875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29876       };
29877     } catch (std::exception& e) {
29878       {
29879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29880       };
29881     } catch (Dali::DaliException e) {
29882       {
29883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29884       };
29885     } catch (...) {
29886       {
29887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29888       };
29889     }
29890   }
29891
29892   jresult = (unsigned long)result;
29893   return jresult;
29894 }
29895
29896
29897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29898   int jresult ;
29899   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29900   std::size_t arg2 ;
29901   int32_t result;
29902
29903   arg1 = (Dali::TouchData *)jarg1;
29904   arg2 = (std::size_t)jarg2;
29905   {
29906     try {
29907       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29908     } catch (std::out_of_range& e) {
29909       {
29910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29911       };
29912     } catch (std::exception& e) {
29913       {
29914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29915       };
29916     } catch (Dali::DaliException e) {
29917       {
29918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29919       };
29920     } catch (...) {
29921       {
29922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29923       };
29924     }
29925   }
29926
29927   jresult = result;
29928   return jresult;
29929 }
29930
29931
29932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29933   int jresult ;
29934   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29935   std::size_t arg2 ;
29936   Dali::PointState::Type result;
29937
29938   arg1 = (Dali::TouchData *)jarg1;
29939   arg2 = (std::size_t)jarg2;
29940   {
29941     try {
29942       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29943     } catch (std::out_of_range& e) {
29944       {
29945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29946       };
29947     } catch (std::exception& e) {
29948       {
29949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29950       };
29951     } catch (Dali::DaliException e) {
29952       {
29953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29954       };
29955     } catch (...) {
29956       {
29957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29958       };
29959     }
29960   }
29961
29962   jresult = (int)result;
29963   return jresult;
29964 }
29965
29966
29967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29968   void * jresult ;
29969   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29970   std::size_t arg2 ;
29971   Dali::Actor result;
29972
29973   arg1 = (Dali::TouchData *)jarg1;
29974   arg2 = (std::size_t)jarg2;
29975   {
29976     try {
29977       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29978     } catch (std::out_of_range& e) {
29979       {
29980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29981       };
29982     } catch (std::exception& e) {
29983       {
29984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29985       };
29986     } catch (Dali::DaliException e) {
29987       {
29988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29989       };
29990     } catch (...) {
29991       {
29992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29993       };
29994     }
29995   }
29996
29997   jresult = new Dali::Actor((const Dali::Actor &)result);
29998   return jresult;
29999 }
30000
30001
30002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30003   void * jresult ;
30004   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30005   std::size_t arg2 ;
30006   Dali::Vector2 *result = 0 ;
30007
30008   arg1 = (Dali::TouchData *)jarg1;
30009   arg2 = (std::size_t)jarg2;
30010   {
30011     try {
30012       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30013     } catch (std::out_of_range& e) {
30014       {
30015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30016       };
30017     } catch (std::exception& e) {
30018       {
30019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30020       };
30021     } catch (Dali::DaliException e) {
30022       {
30023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30024       };
30025     } catch (...) {
30026       {
30027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30028       };
30029     }
30030   }
30031
30032   jresult = (void *)result;
30033   return jresult;
30034 }
30035
30036
30037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30038   void * jresult ;
30039   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30040   std::size_t arg2 ;
30041   Dali::Vector2 *result = 0 ;
30042
30043   arg1 = (Dali::TouchData *)jarg1;
30044   arg2 = (std::size_t)jarg2;
30045   {
30046     try {
30047       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30048     } catch (std::out_of_range& e) {
30049       {
30050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30051       };
30052     } catch (std::exception& e) {
30053       {
30054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30055       };
30056     } catch (Dali::DaliException e) {
30057       {
30058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30059       };
30060     } catch (...) {
30061       {
30062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30063       };
30064     }
30065   }
30066
30067   jresult = (void *)result;
30068   return jresult;
30069 }
30070
30071
30072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30073   float jresult ;
30074   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30075   std::size_t arg2 ;
30076   float result;
30077
30078   arg1 = (Dali::TouchData *)jarg1;
30079   arg2 = (std::size_t)jarg2;
30080   {
30081     try {
30082       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30083     } catch (std::out_of_range& e) {
30084       {
30085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30086       };
30087     } catch (std::exception& e) {
30088       {
30089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30090       };
30091     } catch (Dali::DaliException e) {
30092       {
30093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30094       };
30095     } catch (...) {
30096       {
30097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30098       };
30099     }
30100   }
30101
30102   jresult = result;
30103   return jresult;
30104 }
30105
30106
30107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30108   void * jresult ;
30109   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30110   std::size_t arg2 ;
30111   Dali::Vector2 *result = 0 ;
30112
30113   arg1 = (Dali::TouchData *)jarg1;
30114   arg2 = (std::size_t)jarg2;
30115   {
30116     try {
30117       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30118     } catch (std::out_of_range& e) {
30119       {
30120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30121       };
30122     } catch (std::exception& e) {
30123       {
30124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30125       };
30126     } catch (Dali::DaliException e) {
30127       {
30128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30129       };
30130     } catch (...) {
30131       {
30132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30133       };
30134     }
30135   }
30136
30137   jresult = (void *)result;
30138   return jresult;
30139 }
30140
30141
30142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30143   float jresult ;
30144   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30145   std::size_t arg2 ;
30146   float result;
30147
30148   arg1 = (Dali::TouchData *)jarg1;
30149   arg2 = (std::size_t)jarg2;
30150   {
30151     try {
30152       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30153     } catch (std::out_of_range& e) {
30154       {
30155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30156       };
30157     } catch (std::exception& e) {
30158       {
30159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30160       };
30161     } catch (Dali::DaliException e) {
30162       {
30163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30164       };
30165     } catch (...) {
30166       {
30167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30168       };
30169     }
30170   }
30171
30172   jresult = result;
30173   return jresult;
30174 }
30175
30176
30177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30178   void * jresult ;
30179   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30180   std::size_t arg2 ;
30181   Dali::Degree result;
30182
30183   arg1 = (Dali::TouchData *)jarg1;
30184   arg2 = (std::size_t)jarg2;
30185   {
30186     try {
30187       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30188     } catch (std::out_of_range& e) {
30189       {
30190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30191       };
30192     } catch (std::exception& e) {
30193       {
30194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30195       };
30196     } catch (Dali::DaliException e) {
30197       {
30198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30199       };
30200     } catch (...) {
30201       {
30202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30203       };
30204     }
30205   }
30206
30207   jresult = new Dali::Degree((const Dali::Degree &)result);
30208   return jresult;
30209 }
30210
30211
30212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30213   int jresult ;
30214   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30215   std::size_t arg2 ;
30216   Dali::MouseButton::Type result;
30217
30218   arg1 = (Dali::TouchData *)jarg1;
30219   arg2 = (std::size_t)jarg2;
30220   {
30221     try {
30222       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30223     } catch (std::out_of_range& e) {
30224       {
30225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30226       };
30227     } catch (std::exception& e) {
30228       {
30229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30230       };
30231     } catch (Dali::DaliException e) {
30232       {
30233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30234       };
30235     } catch (...) {
30236       {
30237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30238       };
30239     }
30240   }
30241
30242   jresult = static_cast< int >(result);
30243   return jresult;
30244 }
30245
30246
30247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30248   void * jresult ;
30249   Dali::GestureDetector *result = 0 ;
30250
30251   {
30252     try {
30253       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30254     } catch (std::out_of_range& e) {
30255       {
30256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30257       };
30258     } catch (std::exception& e) {
30259       {
30260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30261       };
30262     } catch (Dali::DaliException e) {
30263       {
30264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30265       };
30266     } catch (...) {
30267       {
30268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30269       };
30270     }
30271   }
30272
30273   jresult = (void *)result;
30274   return jresult;
30275 }
30276
30277
30278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30279   void * jresult ;
30280   Dali::BaseHandle arg1 ;
30281   Dali::BaseHandle *argp1 ;
30282   Dali::GestureDetector result;
30283
30284   argp1 = (Dali::BaseHandle *)jarg1;
30285   if (!argp1) {
30286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30287     return 0;
30288   }
30289   arg1 = *argp1;
30290   {
30291     try {
30292       result = Dali::GestureDetector::DownCast(arg1);
30293     } catch (std::out_of_range& e) {
30294       {
30295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30296       };
30297     } catch (std::exception& e) {
30298       {
30299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30300       };
30301     } catch (Dali::DaliException e) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30304       };
30305     } catch (...) {
30306       {
30307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30308       };
30309     }
30310   }
30311
30312   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30313   return jresult;
30314 }
30315
30316
30317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30318   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30319
30320   arg1 = (Dali::GestureDetector *)jarg1;
30321   {
30322     try {
30323       delete arg1;
30324     } catch (std::out_of_range& e) {
30325       {
30326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30327       };
30328     } catch (std::exception& e) {
30329       {
30330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30331       };
30332     } catch (Dali::DaliException e) {
30333       {
30334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30335       };
30336     } catch (...) {
30337       {
30338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30339       };
30340     }
30341   }
30342
30343 }
30344
30345
30346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30347   void * jresult ;
30348   Dali::GestureDetector *arg1 = 0 ;
30349   Dali::GestureDetector *result = 0 ;
30350
30351   arg1 = (Dali::GestureDetector *)jarg1;
30352   if (!arg1) {
30353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30354     return 0;
30355   }
30356   {
30357     try {
30358       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30359     } catch (std::out_of_range& e) {
30360       {
30361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30362       };
30363     } catch (std::exception& e) {
30364       {
30365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30366       };
30367     } catch (Dali::DaliException e) {
30368       {
30369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30370       };
30371     } catch (...) {
30372       {
30373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30374       };
30375     }
30376   }
30377
30378   jresult = (void *)result;
30379   return jresult;
30380 }
30381
30382
30383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30384   void * jresult ;
30385   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30386   Dali::GestureDetector *arg2 = 0 ;
30387   Dali::GestureDetector *result = 0 ;
30388
30389   arg1 = (Dali::GestureDetector *)jarg1;
30390   arg2 = (Dali::GestureDetector *)jarg2;
30391   if (!arg2) {
30392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30393     return 0;
30394   }
30395   {
30396     try {
30397       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30398     } catch (std::out_of_range& e) {
30399       {
30400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30401       };
30402     } catch (std::exception& e) {
30403       {
30404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30405       };
30406     } catch (Dali::DaliException e) {
30407       {
30408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30409       };
30410     } catch (...) {
30411       {
30412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30413       };
30414     }
30415   }
30416
30417   jresult = (void *)result;
30418   return jresult;
30419 }
30420
30421
30422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30423   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30424   Dali::Actor arg2 ;
30425   Dali::Actor *argp2 ;
30426
30427   arg1 = (Dali::GestureDetector *)jarg1;
30428   argp2 = (Dali::Actor *)jarg2;
30429   if (!argp2) {
30430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30431     return ;
30432   }
30433   arg2 = *argp2;
30434   {
30435     try {
30436       (arg1)->Attach(arg2);
30437     } catch (std::out_of_range& e) {
30438       {
30439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30440       };
30441     } catch (std::exception& e) {
30442       {
30443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30444       };
30445     } catch (Dali::DaliException e) {
30446       {
30447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30448       };
30449     } catch (...) {
30450       {
30451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30452       };
30453     }
30454   }
30455
30456 }
30457
30458
30459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30460   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30461   Dali::Actor arg2 ;
30462   Dali::Actor *argp2 ;
30463
30464   arg1 = (Dali::GestureDetector *)jarg1;
30465   argp2 = (Dali::Actor *)jarg2;
30466   if (!argp2) {
30467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30468     return ;
30469   }
30470   arg2 = *argp2;
30471   {
30472     try {
30473       (arg1)->Detach(arg2);
30474     } catch (std::out_of_range& e) {
30475       {
30476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30477       };
30478     } catch (std::exception& e) {
30479       {
30480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30481       };
30482     } catch (Dali::DaliException e) {
30483       {
30484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30485       };
30486     } catch (...) {
30487       {
30488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30489       };
30490     }
30491   }
30492
30493 }
30494
30495
30496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30497   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30498
30499   arg1 = (Dali::GestureDetector *)jarg1;
30500   {
30501     try {
30502       (arg1)->DetachAll();
30503     } catch (std::out_of_range& e) {
30504       {
30505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30506       };
30507     } catch (std::exception& e) {
30508       {
30509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30510       };
30511     } catch (Dali::DaliException e) {
30512       {
30513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30514       };
30515     } catch (...) {
30516       {
30517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30518       };
30519     }
30520   }
30521
30522 }
30523
30524
30525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30526   unsigned long jresult ;
30527   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30528   size_t result;
30529
30530   arg1 = (Dali::GestureDetector *)jarg1;
30531   {
30532     try {
30533       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30534     } catch (std::out_of_range& e) {
30535       {
30536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30537       };
30538     } catch (std::exception& e) {
30539       {
30540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30541       };
30542     } catch (Dali::DaliException e) {
30543       {
30544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30545       };
30546     } catch (...) {
30547       {
30548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30549       };
30550     }
30551   }
30552
30553   jresult = (unsigned long)result;
30554   return jresult;
30555 }
30556
30557
30558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30559   void * jresult ;
30560   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30561   size_t arg2 ;
30562   Dali::Actor result;
30563
30564   arg1 = (Dali::GestureDetector *)jarg1;
30565   arg2 = (size_t)jarg2;
30566   {
30567     try {
30568       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30569     } catch (std::out_of_range& e) {
30570       {
30571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30572       };
30573     } catch (std::exception& e) {
30574       {
30575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30576       };
30577     } catch (Dali::DaliException e) {
30578       {
30579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30580       };
30581     } catch (...) {
30582       {
30583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30584       };
30585     }
30586   }
30587
30588   jresult = new Dali::Actor((const Dali::Actor &)result);
30589   return jresult;
30590 }
30591
30592
30593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30594   void * jresult ;
30595   Dali::Gesture *arg1 = 0 ;
30596   Dali::Gesture *result = 0 ;
30597
30598   arg1 = (Dali::Gesture *)jarg1;
30599   if (!arg1) {
30600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30601     return 0;
30602   }
30603   {
30604     try {
30605       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30606     } catch (std::out_of_range& e) {
30607       {
30608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30609       };
30610     } catch (std::exception& e) {
30611       {
30612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30613       };
30614     } catch (Dali::DaliException e) {
30615       {
30616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30617       };
30618     } catch (...) {
30619       {
30620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30621       };
30622     }
30623   }
30624
30625   jresult = (void *)result;
30626   return jresult;
30627 }
30628
30629
30630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30631   void * jresult ;
30632   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30633   Dali::Gesture *arg2 = 0 ;
30634   Dali::Gesture *result = 0 ;
30635
30636   arg1 = (Dali::Gesture *)jarg1;
30637   arg2 = (Dali::Gesture *)jarg2;
30638   if (!arg2) {
30639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30640     return 0;
30641   }
30642   {
30643     try {
30644       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30645     } catch (std::out_of_range& e) {
30646       {
30647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30648       };
30649     } catch (std::exception& e) {
30650       {
30651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30652       };
30653     } catch (Dali::DaliException e) {
30654       {
30655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30656       };
30657     } catch (...) {
30658       {
30659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30660       };
30661     }
30662   }
30663
30664   jresult = (void *)result;
30665   return jresult;
30666 }
30667
30668
30669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30670   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30671
30672   arg1 = (Dali::Gesture *)jarg1;
30673   {
30674     try {
30675       delete arg1;
30676     } catch (std::out_of_range& e) {
30677       {
30678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30679       };
30680     } catch (std::exception& e) {
30681       {
30682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30683       };
30684     } catch (Dali::DaliException e) {
30685       {
30686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30687       };
30688     } catch (...) {
30689       {
30690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30691       };
30692     }
30693   }
30694
30695 }
30696
30697
30698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30699   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30700   Dali::Gesture::Type arg2 ;
30701
30702   arg1 = (Dali::Gesture *)jarg1;
30703   arg2 = (Dali::Gesture::Type)jarg2;
30704   if (arg1) (arg1)->type = arg2;
30705 }
30706
30707
30708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30709   int jresult ;
30710   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30711   Dali::Gesture::Type result;
30712
30713   arg1 = (Dali::Gesture *)jarg1;
30714   result = (Dali::Gesture::Type) ((arg1)->type);
30715   jresult = (int)result;
30716   return jresult;
30717 }
30718
30719
30720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30721   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30722   Dali::Gesture::State arg2 ;
30723
30724   arg1 = (Dali::Gesture *)jarg1;
30725   arg2 = (Dali::Gesture::State)jarg2;
30726   if (arg1) (arg1)->state = arg2;
30727 }
30728
30729
30730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30731   int jresult ;
30732   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30733   Dali::Gesture::State result;
30734
30735   arg1 = (Dali::Gesture *)jarg1;
30736   result = (Dali::Gesture::State) ((arg1)->state);
30737   jresult = (int)result;
30738   return jresult;
30739 }
30740
30741
30742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30743   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30744   unsigned int arg2 ;
30745
30746   arg1 = (Dali::Gesture *)jarg1;
30747   arg2 = (unsigned int)jarg2;
30748   if (arg1) (arg1)->time = arg2;
30749 }
30750
30751
30752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30753   unsigned int jresult ;
30754   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30755   unsigned int result;
30756
30757   arg1 = (Dali::Gesture *)jarg1;
30758   result = (unsigned int) ((arg1)->time);
30759   jresult = result;
30760   return jresult;
30761 }
30762
30763
30764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30765   void * jresult ;
30766   Dali::HoverEvent *result = 0 ;
30767
30768   {
30769     try {
30770       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30771     } catch (std::out_of_range& e) {
30772       {
30773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30774       };
30775     } catch (std::exception& e) {
30776       {
30777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30778       };
30779     } catch (Dali::DaliException e) {
30780       {
30781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30782       };
30783     } catch (...) {
30784       {
30785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30786       };
30787     }
30788   }
30789
30790   jresult = (void *)result;
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30796   void * jresult ;
30797   unsigned long arg1 ;
30798   Dali::HoverEvent *result = 0 ;
30799
30800   arg1 = (unsigned long)jarg1;
30801   {
30802     try {
30803       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30804     } catch (std::out_of_range& e) {
30805       {
30806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (std::exception& e) {
30809       {
30810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30811       };
30812     } catch (Dali::DaliException e) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30815       };
30816     } catch (...) {
30817       {
30818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30819       };
30820     }
30821   }
30822
30823   jresult = (void *)result;
30824   return jresult;
30825 }
30826
30827
30828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30829   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30830
30831   arg1 = (Dali::HoverEvent *)jarg1;
30832   {
30833     try {
30834       delete arg1;
30835     } catch (std::out_of_range& e) {
30836       {
30837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30838       };
30839     } catch (std::exception& e) {
30840       {
30841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30842       };
30843     } catch (Dali::DaliException e) {
30844       {
30845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30846       };
30847     } catch (...) {
30848       {
30849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30850       };
30851     }
30852   }
30853
30854 }
30855
30856
30857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30858   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30859   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30860
30861   arg1 = (Dali::HoverEvent *)jarg1;
30862   arg2 = (Dali::TouchPointContainer *)jarg2;
30863   if (arg1) (arg1)->points = *arg2;
30864 }
30865
30866
30867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30868   void * jresult ;
30869   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30870   Dali::TouchPointContainer *result = 0 ;
30871
30872   arg1 = (Dali::HoverEvent *)jarg1;
30873   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30874   jresult = (void *)result;
30875   return jresult;
30876 }
30877
30878
30879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30880   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30881   unsigned long arg2 ;
30882
30883   arg1 = (Dali::HoverEvent *)jarg1;
30884   arg2 = (unsigned long)jarg2;
30885   if (arg1) (arg1)->time = arg2;
30886 }
30887
30888
30889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30890   unsigned long jresult ;
30891   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30892   unsigned long result;
30893
30894   arg1 = (Dali::HoverEvent *)jarg1;
30895   result = (unsigned long) ((arg1)->time);
30896   jresult = (unsigned long)result;
30897   return jresult;
30898 }
30899
30900
30901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30902   unsigned int jresult ;
30903   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30904   unsigned int result;
30905
30906   arg1 = (Dali::HoverEvent *)jarg1;
30907   {
30908     try {
30909       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30910     } catch (std::out_of_range& e) {
30911       {
30912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30913       };
30914     } catch (std::exception& e) {
30915       {
30916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30917       };
30918     } catch (Dali::DaliException e) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30921       };
30922     } catch (...) {
30923       {
30924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30925       };
30926     }
30927   }
30928
30929   jresult = result;
30930   return jresult;
30931 }
30932
30933
30934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30935   void * jresult ;
30936   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30937   unsigned int arg2 ;
30938   Dali::TouchPoint *result = 0 ;
30939
30940   arg1 = (Dali::HoverEvent *)jarg1;
30941   arg2 = (unsigned int)jarg2;
30942   {
30943     try {
30944       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30945     } catch (std::out_of_range& e) {
30946       {
30947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (std::exception& e) {
30950       {
30951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30952       };
30953     } catch (Dali::DaliException e) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30956       };
30957     } catch (...) {
30958       {
30959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30960       };
30961     }
30962   }
30963
30964   jresult = (void *)result;
30965   return jresult;
30966 }
30967
30968
30969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30970   void * jresult ;
30971   Dali::KeyEvent *result = 0 ;
30972
30973   {
30974     try {
30975       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30976     } catch (std::out_of_range& e) {
30977       {
30978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30979       };
30980     } catch (std::exception& e) {
30981       {
30982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30983       };
30984     } catch (Dali::DaliException e) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30987       };
30988     } catch (...) {
30989       {
30990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30991       };
30992     }
30993   }
30994
30995   jresult = (void *)result;
30996   return jresult;
30997 }
30998
30999
31000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31001   void * jresult ;
31002   std::string *arg1 = 0 ;
31003   std::string *arg2 = 0 ;
31004   int arg3 ;
31005   int arg4 ;
31006   unsigned long arg5 ;
31007   Dali::KeyEvent::State *arg6 = 0 ;
31008   Dali::KeyEvent::State temp6 ;
31009   Dali::KeyEvent *result = 0 ;
31010
31011   if (!jarg1) {
31012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31013     return 0;
31014   }
31015   std::string arg1_str(jarg1);
31016   arg1 = &arg1_str;
31017   if (!jarg2) {
31018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31019     return 0;
31020   }
31021   std::string arg2_str(jarg2);
31022   arg2 = &arg2_str;
31023   arg3 = (int)jarg3;
31024   arg4 = (int)jarg4;
31025   arg5 = (unsigned long)jarg5;
31026   temp6 = (Dali::KeyEvent::State)jarg6;
31027   arg6 = &temp6;
31028   {
31029     try {
31030       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31031     } catch (std::out_of_range& e) {
31032       {
31033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31034       };
31035     } catch (std::exception& e) {
31036       {
31037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31038       };
31039     } catch (Dali::DaliException e) {
31040       {
31041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31042       };
31043     } catch (...) {
31044       {
31045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31046       };
31047     }
31048   }
31049
31050   jresult = (void *)result;
31051
31052   //argout typemap for const std::string&
31053
31054
31055   //argout typemap for const std::string&
31056
31057   return jresult;
31058 }
31059
31060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31061   void * jresult ;
31062   Dali::KeyEvent *arg1 = 0 ;
31063   Dali::KeyEvent *result = 0 ;
31064
31065   arg1 = (Dali::KeyEvent *)jarg1;
31066   if (!arg1) {
31067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31068     return 0;
31069   }
31070   {
31071     try {
31072       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31073     } catch (std::out_of_range& e) {
31074       {
31075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (std::exception& e) {
31078       {
31079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31080       };
31081     } catch (Dali::DaliException e) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31084       };
31085     } catch (...) {
31086       {
31087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31088       };
31089     }
31090   }
31091
31092   jresult = (void *)result;
31093   return jresult;
31094 }
31095
31096
31097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31098   void * jresult ;
31099   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31100   Dali::KeyEvent *arg2 = 0 ;
31101   Dali::KeyEvent *result = 0 ;
31102
31103   arg1 = (Dali::KeyEvent *)jarg1;
31104   arg2 = (Dali::KeyEvent *)jarg2;
31105   if (!arg2) {
31106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31107     return 0;
31108   }
31109   {
31110     try {
31111       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31112     } catch (std::out_of_range& e) {
31113       {
31114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (std::exception& e) {
31117       {
31118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31119       };
31120     } catch (Dali::DaliException e) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31123       };
31124     } catch (...) {
31125       {
31126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31127       };
31128     }
31129   }
31130
31131   jresult = (void *)result;
31132   return jresult;
31133 }
31134
31135
31136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31137   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31138
31139   arg1 = (Dali::KeyEvent *)jarg1;
31140   {
31141     try {
31142       delete arg1;
31143     } catch (std::out_of_range& e) {
31144       {
31145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (std::exception& e) {
31148       {
31149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31150       };
31151     } catch (Dali::DaliException e) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31154       };
31155     } catch (...) {
31156       {
31157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31158       };
31159     }
31160   }
31161
31162 }
31163
31164
31165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31166   unsigned int jresult ;
31167   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31168   bool result;
31169
31170   arg1 = (Dali::KeyEvent *)jarg1;
31171   {
31172     try {
31173       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31174     } catch (std::out_of_range& e) {
31175       {
31176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31177       };
31178     } catch (std::exception& e) {
31179       {
31180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31181       };
31182     } catch (Dali::DaliException e) {
31183       {
31184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31185       };
31186     } catch (...) {
31187       {
31188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31189       };
31190     }
31191   }
31192
31193   jresult = result;
31194   return jresult;
31195 }
31196
31197
31198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31199   unsigned int jresult ;
31200   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31201   bool result;
31202
31203   arg1 = (Dali::KeyEvent *)jarg1;
31204   {
31205     try {
31206       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31207     } catch (std::out_of_range& e) {
31208       {
31209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (std::exception& e) {
31212       {
31213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31214       };
31215     } catch (Dali::DaliException e) {
31216       {
31217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31218       };
31219     } catch (...) {
31220       {
31221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31222       };
31223     }
31224   }
31225
31226   jresult = result;
31227   return jresult;
31228 }
31229
31230
31231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31232   unsigned int jresult ;
31233   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31234   bool result;
31235
31236   arg1 = (Dali::KeyEvent *)jarg1;
31237   {
31238     try {
31239       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31240     } catch (std::out_of_range& e) {
31241       {
31242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31243       };
31244     } catch (std::exception& e) {
31245       {
31246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31247       };
31248     } catch (Dali::DaliException e) {
31249       {
31250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31251       };
31252     } catch (...) {
31253       {
31254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31255       };
31256     }
31257   }
31258
31259   jresult = result;
31260   return jresult;
31261 }
31262
31263
31264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31265   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31266   std::string *arg2 = 0 ;
31267
31268   arg1 = (Dali::KeyEvent *)jarg1;
31269   if (!jarg2) {
31270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31271     return ;
31272   }
31273   std::string arg2_str(jarg2);
31274   arg2 = &arg2_str;
31275   if (arg1) (arg1)->keyPressedName = *arg2;
31276
31277   //argout typemap for const std::string&
31278
31279 }
31280
31281
31282 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31283   char * jresult ;
31284
31285   if( jarg1 == NULL )
31286   {
31287     jresult = SWIG_csharp_string_callback( "" );
31288   }
31289   else
31290   {
31291     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31292     std::string *result = 0;
31293
31294     arg1 = ( Dali::KeyEvent * )jarg1;
31295     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31296     jresult = SWIG_csharp_string_callback( result->c_str() );
31297   }
31298
31299   return jresult;
31300 }
31301
31302
31303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31304   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31305   std::string *arg2 = 0 ;
31306
31307   arg1 = (Dali::KeyEvent *)jarg1;
31308   if (!jarg2) {
31309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31310     return ;
31311   }
31312   std::string arg2_str(jarg2);
31313   arg2 = &arg2_str;
31314   if (arg1) (arg1)->keyPressed = *arg2;
31315
31316   //argout typemap for const std::string&
31317
31318 }
31319
31320
31321 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31322   char * jresult ;
31323   if( NULL == jarg1 )
31324   {
31325     jresult = SWIG_csharp_string_callback( "" );
31326   }
31327   else
31328   {
31329     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31330     std::string *result = 0;
31331
31332     arg1 = ( Dali::KeyEvent * )jarg1;
31333     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31334     jresult = SWIG_csharp_string_callback( result->c_str() );
31335   }
31336   return jresult;
31337 }
31338
31339
31340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31341   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31342   int arg2 ;
31343
31344   arg1 = (Dali::KeyEvent *)jarg1;
31345   arg2 = (int)jarg2;
31346   if (arg1) (arg1)->keyCode = arg2;
31347 }
31348
31349
31350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31351   int jresult ;
31352   if( NULL == jarg1 )
31353   {
31354     jresult = -1;
31355   }
31356   else
31357   {
31358     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31359     int result;
31360
31361     arg1 = ( Dali::KeyEvent * )jarg1;
31362     result = (int)( ( arg1 )->keyCode );
31363     jresult = result;
31364   }
31365   return jresult;
31366 }
31367
31368
31369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31370   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31371   int arg2 ;
31372
31373   arg1 = (Dali::KeyEvent *)jarg1;
31374   arg2 = (int)jarg2;
31375   if (arg1) (arg1)->keyModifier = arg2;
31376 }
31377
31378
31379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31380   int jresult ;
31381   if( jarg1 == NULL )
31382   {
31383     jresult = -1;
31384   }
31385   else
31386   {
31387     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31388     int result;
31389
31390     arg1 = ( Dali::KeyEvent * )jarg1;
31391     result = (int)( ( arg1 )->keyModifier );
31392     jresult = result;
31393   }
31394   return jresult;
31395 }
31396
31397
31398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31399   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31400   unsigned long arg2 ;
31401
31402   arg1 = (Dali::KeyEvent *)jarg1;
31403   arg2 = (unsigned long)jarg2;
31404   if (arg1) (arg1)->time = arg2;
31405 }
31406
31407
31408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31409   unsigned long jresult ;
31410   if( jarg1 == NULL )
31411   {
31412     jresult = 0;
31413   }
31414   else
31415   {
31416     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31417     unsigned long result;
31418
31419     arg1 = ( Dali::KeyEvent * )jarg1;
31420     result = (unsigned long)( ( arg1 )->time );
31421     jresult = (unsigned long)result;
31422   }
31423   return jresult;
31424 }
31425
31426
31427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31428   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31429   Dali::KeyEvent::State arg2 ;
31430
31431   arg1 = (Dali::KeyEvent *)jarg1;
31432   arg2 = (Dali::KeyEvent::State)jarg2;
31433   if (arg1) (arg1)->state = arg2;
31434 }
31435
31436
31437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31438   int jresult ;
31439   if( jarg1 == NULL )
31440   {
31441     jresult = -1;
31442   }
31443   else
31444   {
31445     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31446     Dali::KeyEvent::State result;
31447
31448     arg1 = ( Dali::KeyEvent * )jarg1;
31449     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31450     jresult = (int)result;
31451   }
31452   return jresult;
31453 }
31454
31455
31456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31457   void * jresult ;
31458   Dali::LongPressGestureDetector *result = 0 ;
31459
31460   {
31461     try {
31462       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31463     } catch (std::out_of_range& e) {
31464       {
31465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (std::exception& e) {
31468       {
31469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (Dali::DaliException e) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31474       };
31475     } catch (...) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31478       };
31479     }
31480   }
31481
31482   jresult = (void *)result;
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31488   void * jresult ;
31489   Dali::LongPressGestureDetector result;
31490
31491   {
31492     try {
31493       result = Dali::LongPressGestureDetector::New();
31494     } catch (std::out_of_range& e) {
31495       {
31496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31497       };
31498     } catch (std::exception& e) {
31499       {
31500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31501       };
31502     } catch (Dali::DaliException e) {
31503       {
31504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31505       };
31506     } catch (...) {
31507       {
31508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31509       };
31510     }
31511   }
31512
31513   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31514   return jresult;
31515 }
31516
31517
31518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31519   void * jresult ;
31520   unsigned int arg1 ;
31521   Dali::LongPressGestureDetector result;
31522
31523   arg1 = (unsigned int)jarg1;
31524   {
31525     try {
31526       result = Dali::LongPressGestureDetector::New(arg1);
31527     } catch (std::out_of_range& e) {
31528       {
31529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31530       };
31531     } catch (std::exception& e) {
31532       {
31533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31534       };
31535     } catch (Dali::DaliException e) {
31536       {
31537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31538       };
31539     } catch (...) {
31540       {
31541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31542       };
31543     }
31544   }
31545
31546   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31547   return jresult;
31548 }
31549
31550
31551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31552   void * jresult ;
31553   unsigned int arg1 ;
31554   unsigned int arg2 ;
31555   Dali::LongPressGestureDetector result;
31556
31557   arg1 = (unsigned int)jarg1;
31558   arg2 = (unsigned int)jarg2;
31559   {
31560     try {
31561       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31562     } catch (std::out_of_range& e) {
31563       {
31564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31565       };
31566     } catch (std::exception& e) {
31567       {
31568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31569       };
31570     } catch (Dali::DaliException e) {
31571       {
31572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31573       };
31574     } catch (...) {
31575       {
31576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31577       };
31578     }
31579   }
31580
31581   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31582   return jresult;
31583 }
31584
31585
31586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31587   void * jresult ;
31588   Dali::BaseHandle arg1 ;
31589   Dali::BaseHandle *argp1 ;
31590   Dali::LongPressGestureDetector result;
31591
31592   argp1 = (Dali::BaseHandle *)jarg1;
31593   if (!argp1) {
31594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31595     return 0;
31596   }
31597   arg1 = *argp1;
31598   {
31599     try {
31600       result = Dali::LongPressGestureDetector::DownCast(arg1);
31601     } catch (std::out_of_range& e) {
31602       {
31603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31604       };
31605     } catch (std::exception& e) {
31606       {
31607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31608       };
31609     } catch (Dali::DaliException e) {
31610       {
31611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31612       };
31613     } catch (...) {
31614       {
31615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31616       };
31617     }
31618   }
31619
31620   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31621   return jresult;
31622 }
31623
31624
31625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31626   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31627
31628   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31629   {
31630     try {
31631       delete arg1;
31632     } catch (std::out_of_range& e) {
31633       {
31634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31635       };
31636     } catch (std::exception& e) {
31637       {
31638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31639       };
31640     } catch (Dali::DaliException e) {
31641       {
31642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31643       };
31644     } catch (...) {
31645       {
31646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31647       };
31648     }
31649   }
31650
31651 }
31652
31653
31654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31655   void * jresult ;
31656   Dali::LongPressGestureDetector *arg1 = 0 ;
31657   Dali::LongPressGestureDetector *result = 0 ;
31658
31659   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31660   if (!arg1) {
31661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31662     return 0;
31663   }
31664   {
31665     try {
31666       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31667     } catch (std::out_of_range& e) {
31668       {
31669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31670       };
31671     } catch (std::exception& e) {
31672       {
31673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31674       };
31675     } catch (Dali::DaliException e) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31678       };
31679     } catch (...) {
31680       {
31681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31682       };
31683     }
31684   }
31685
31686   jresult = (void *)result;
31687   return jresult;
31688 }
31689
31690
31691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31692   void * jresult ;
31693   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31694   Dali::LongPressGestureDetector *arg2 = 0 ;
31695   Dali::LongPressGestureDetector *result = 0 ;
31696
31697   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31698   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31699   if (!arg2) {
31700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31701     return 0;
31702   }
31703   {
31704     try {
31705       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31706     } catch (std::out_of_range& e) {
31707       {
31708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (std::exception& e) {
31711       {
31712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31713       };
31714     } catch (Dali::DaliException e) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31717       };
31718     } catch (...) {
31719       {
31720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31721       };
31722     }
31723   }
31724
31725   jresult = (void *)result;
31726   return jresult;
31727 }
31728
31729
31730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31731   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31732   unsigned int arg2 ;
31733
31734   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31735   arg2 = (unsigned int)jarg2;
31736   {
31737     try {
31738       (arg1)->SetTouchesRequired(arg2);
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31746       };
31747     } catch (Dali::DaliException e) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31750       };
31751     } catch (...) {
31752       {
31753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31754       };
31755     }
31756   }
31757
31758 }
31759
31760
31761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31762   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31763   unsigned int arg2 ;
31764   unsigned int arg3 ;
31765
31766   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31767   arg2 = (unsigned int)jarg2;
31768   arg3 = (unsigned int)jarg3;
31769   {
31770     try {
31771       (arg1)->SetTouchesRequired(arg2,arg3);
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31779       };
31780     } catch (Dali::DaliException e) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31783       };
31784     } catch (...) {
31785       {
31786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31787       };
31788     }
31789   }
31790
31791 }
31792
31793
31794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31795   unsigned int jresult ;
31796   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31797   unsigned int result;
31798
31799   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31800   {
31801     try {
31802       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31803     } catch (std::out_of_range& e) {
31804       {
31805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31806       };
31807     } catch (std::exception& e) {
31808       {
31809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31810       };
31811     } catch (Dali::DaliException e) {
31812       {
31813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31814       };
31815     } catch (...) {
31816       {
31817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31818       };
31819     }
31820   }
31821
31822   jresult = result;
31823   return jresult;
31824 }
31825
31826
31827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31828   unsigned int jresult ;
31829   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31830   unsigned int result;
31831
31832   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31833   {
31834     try {
31835       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31836     } catch (std::out_of_range& e) {
31837       {
31838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31839       };
31840     } catch (std::exception& e) {
31841       {
31842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31843       };
31844     } catch (Dali::DaliException e) {
31845       {
31846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31847       };
31848     } catch (...) {
31849       {
31850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31851       };
31852     }
31853   }
31854
31855   jresult = result;
31856   return jresult;
31857 }
31858
31859
31860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31861   void * jresult ;
31862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31863   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31864
31865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31866   {
31867     try {
31868       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31869     } catch (std::out_of_range& e) {
31870       {
31871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31872       };
31873     } catch (std::exception& e) {
31874       {
31875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31876       };
31877     } catch (Dali::DaliException e) {
31878       {
31879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31880       };
31881     } catch (...) {
31882       {
31883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31884       };
31885     }
31886   }
31887
31888   jresult = (void *)result;
31889   return jresult;
31890 }
31891
31892
31893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31894   void * jresult ;
31895   Dali::Gesture::State arg1 ;
31896   Dali::LongPressGesture *result = 0 ;
31897
31898   arg1 = (Dali::Gesture::State)jarg1;
31899   {
31900     try {
31901       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31902     } catch (std::out_of_range& e) {
31903       {
31904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31905       };
31906     } catch (std::exception& e) {
31907       {
31908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31909       };
31910     } catch (Dali::DaliException e) {
31911       {
31912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31913       };
31914     } catch (...) {
31915       {
31916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31917       };
31918     }
31919   }
31920
31921   jresult = (void *)result;
31922   return jresult;
31923 }
31924
31925
31926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31927   void * jresult ;
31928   Dali::LongPressGesture *arg1 = 0 ;
31929   Dali::LongPressGesture *result = 0 ;
31930
31931   arg1 = (Dali::LongPressGesture *)jarg1;
31932   if (!arg1) {
31933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31934     return 0;
31935   }
31936   {
31937     try {
31938       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31939     } catch (std::out_of_range& e) {
31940       {
31941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31942       };
31943     } catch (std::exception& e) {
31944       {
31945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31946       };
31947     } catch (Dali::DaliException e) {
31948       {
31949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31950       };
31951     } catch (...) {
31952       {
31953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31954       };
31955     }
31956   }
31957
31958   jresult = (void *)result;
31959   return jresult;
31960 }
31961
31962
31963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31964   void * jresult ;
31965   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31966   Dali::LongPressGesture *arg2 = 0 ;
31967   Dali::LongPressGesture *result = 0 ;
31968
31969   arg1 = (Dali::LongPressGesture *)jarg1;
31970   arg2 = (Dali::LongPressGesture *)jarg2;
31971   if (!arg2) {
31972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31973     return 0;
31974   }
31975   {
31976     try {
31977       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31978     } catch (std::out_of_range& e) {
31979       {
31980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31981       };
31982     } catch (std::exception& e) {
31983       {
31984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31985       };
31986     } catch (Dali::DaliException e) {
31987       {
31988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31989       };
31990     } catch (...) {
31991       {
31992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31993       };
31994     }
31995   }
31996
31997   jresult = (void *)result;
31998   return jresult;
31999 }
32000
32001
32002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32003   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32004
32005   arg1 = (Dali::LongPressGesture *)jarg1;
32006   {
32007     try {
32008       delete arg1;
32009     } catch (std::out_of_range& e) {
32010       {
32011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32012       };
32013     } catch (std::exception& e) {
32014       {
32015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32016       };
32017     } catch (Dali::DaliException e) {
32018       {
32019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32020       };
32021     } catch (...) {
32022       {
32023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32024       };
32025     }
32026   }
32027
32028 }
32029
32030
32031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32032   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32033   unsigned int arg2 ;
32034
32035   arg1 = (Dali::LongPressGesture *)jarg1;
32036   arg2 = (unsigned int)jarg2;
32037   if (arg1) (arg1)->numberOfTouches = arg2;
32038 }
32039
32040
32041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32042   unsigned int jresult ;
32043   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32044   unsigned int result;
32045
32046   arg1 = (Dali::LongPressGesture *)jarg1;
32047   result = (unsigned int) ((arg1)->numberOfTouches);
32048   jresult = result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32054   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32055   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32056
32057   arg1 = (Dali::LongPressGesture *)jarg1;
32058   arg2 = (Dali::Vector2 *)jarg2;
32059   if (arg1) (arg1)->screenPoint = *arg2;
32060 }
32061
32062
32063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32064   void * jresult ;
32065   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32066   Dali::Vector2 *result = 0 ;
32067
32068   arg1 = (Dali::LongPressGesture *)jarg1;
32069   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32070   jresult = (void *)result;
32071   return jresult;
32072 }
32073
32074
32075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32076   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32077   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32078
32079   arg1 = (Dali::LongPressGesture *)jarg1;
32080   arg2 = (Dali::Vector2 *)jarg2;
32081   if (arg1) (arg1)->localPoint = *arg2;
32082 }
32083
32084
32085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32086   void * jresult ;
32087   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32088   Dali::Vector2 *result = 0 ;
32089
32090   arg1 = (Dali::LongPressGesture *)jarg1;
32091   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32092   jresult = (void *)result;
32093   return jresult;
32094 }
32095
32096
32097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32098   void * jresult ;
32099   Dali::WheelEvent *result = 0 ;
32100
32101   {
32102     try {
32103       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32104     } catch (std::out_of_range& e) {
32105       {
32106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32107       };
32108     } catch (std::exception& e) {
32109       {
32110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32111       };
32112     } catch (Dali::DaliException e) {
32113       {
32114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32115       };
32116     } catch (...) {
32117       {
32118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32119       };
32120     }
32121   }
32122
32123   jresult = (void *)result;
32124   return jresult;
32125 }
32126
32127
32128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32129   void * jresult ;
32130   Dali::WheelEvent::Type arg1 ;
32131   int arg2 ;
32132   unsigned int arg3 ;
32133   Dali::Vector2 arg4 ;
32134   int arg5 ;
32135   unsigned int arg6 ;
32136   Dali::Vector2 *argp4 ;
32137   Dali::WheelEvent *result = 0 ;
32138
32139   arg1 = (Dali::WheelEvent::Type)jarg1;
32140   arg2 = (int)jarg2;
32141   arg3 = (unsigned int)jarg3;
32142   argp4 = (Dali::Vector2 *)jarg4;
32143   if (!argp4) {
32144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32145     return 0;
32146   }
32147   arg4 = *argp4;
32148   arg5 = (int)jarg5;
32149   arg6 = (unsigned int)jarg6;
32150   {
32151     try {
32152       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32153     } catch (std::out_of_range& e) {
32154       {
32155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32156       };
32157     } catch (std::exception& e) {
32158       {
32159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32160       };
32161     } catch (Dali::DaliException e) {
32162       {
32163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32164       };
32165     } catch (...) {
32166       {
32167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32168       };
32169     }
32170   }
32171
32172   jresult = (void *)result;
32173   return jresult;
32174 }
32175
32176
32177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32178   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32179
32180   arg1 = (Dali::WheelEvent *)jarg1;
32181   {
32182     try {
32183       delete arg1;
32184     } catch (std::out_of_range& e) {
32185       {
32186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32187       };
32188     } catch (std::exception& e) {
32189       {
32190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32191       };
32192     } catch (Dali::DaliException e) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32195       };
32196     } catch (...) {
32197       {
32198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32199       };
32200     }
32201   }
32202
32203 }
32204
32205
32206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32207   unsigned int jresult ;
32208   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32209   bool result;
32210
32211   arg1 = (Dali::WheelEvent *)jarg1;
32212   {
32213     try {
32214       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32215     } catch (std::out_of_range& e) {
32216       {
32217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32218       };
32219     } catch (std::exception& e) {
32220       {
32221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32222       };
32223     } catch (Dali::DaliException e) {
32224       {
32225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32226       };
32227     } catch (...) {
32228       {
32229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32230       };
32231     }
32232   }
32233
32234   jresult = result;
32235   return jresult;
32236 }
32237
32238
32239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32240   unsigned int jresult ;
32241   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32242   bool result;
32243
32244   arg1 = (Dali::WheelEvent *)jarg1;
32245   {
32246     try {
32247       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32248     } catch (std::out_of_range& e) {
32249       {
32250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32251       };
32252     } catch (std::exception& e) {
32253       {
32254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (Dali::DaliException e) {
32257       {
32258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32259       };
32260     } catch (...) {
32261       {
32262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32263       };
32264     }
32265   }
32266
32267   jresult = result;
32268   return jresult;
32269 }
32270
32271
32272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32273   unsigned int jresult ;
32274   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32275   bool result;
32276
32277   arg1 = (Dali::WheelEvent *)jarg1;
32278   {
32279     try {
32280       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32281     } catch (std::out_of_range& e) {
32282       {
32283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32284       };
32285     } catch (std::exception& e) {
32286       {
32287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32288       };
32289     } catch (Dali::DaliException e) {
32290       {
32291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32292       };
32293     } catch (...) {
32294       {
32295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32296       };
32297     }
32298   }
32299
32300   jresult = result;
32301   return jresult;
32302 }
32303
32304
32305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32307   Dali::WheelEvent::Type arg2 ;
32308
32309   arg1 = (Dali::WheelEvent *)jarg1;
32310   arg2 = (Dali::WheelEvent::Type)jarg2;
32311   if (arg1) (arg1)->type = arg2;
32312 }
32313
32314
32315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32316   int jresult ;
32317   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32318   Dali::WheelEvent::Type result;
32319
32320   arg1 = (Dali::WheelEvent *)jarg1;
32321   result = (Dali::WheelEvent::Type) ((arg1)->type);
32322   jresult = (int)result;
32323   return jresult;
32324 }
32325
32326
32327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32329   int arg2 ;
32330
32331   arg1 = (Dali::WheelEvent *)jarg1;
32332   arg2 = (int)jarg2;
32333   if (arg1) (arg1)->direction = arg2;
32334 }
32335
32336
32337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32338   int jresult ;
32339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32340   int result;
32341
32342   arg1 = (Dali::WheelEvent *)jarg1;
32343   result = (int) ((arg1)->direction);
32344   jresult = result;
32345   return jresult;
32346 }
32347
32348
32349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32351   unsigned int arg2 ;
32352
32353   arg1 = (Dali::WheelEvent *)jarg1;
32354   arg2 = (unsigned int)jarg2;
32355   if (arg1) (arg1)->modifiers = arg2;
32356 }
32357
32358
32359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32360   unsigned int jresult ;
32361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32362   unsigned int result;
32363
32364   arg1 = (Dali::WheelEvent *)jarg1;
32365   result = (unsigned int) ((arg1)->modifiers);
32366   jresult = result;
32367   return jresult;
32368 }
32369
32370
32371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32373   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32374
32375   arg1 = (Dali::WheelEvent *)jarg1;
32376   arg2 = (Dali::Vector2 *)jarg2;
32377   if (arg1) (arg1)->point = *arg2;
32378 }
32379
32380
32381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32382   void * jresult ;
32383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32384   Dali::Vector2 *result = 0 ;
32385
32386   arg1 = (Dali::WheelEvent *)jarg1;
32387   result = (Dali::Vector2 *)& ((arg1)->point);
32388   jresult = (void *)result;
32389   return jresult;
32390 }
32391
32392
32393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32395   int arg2 ;
32396
32397   arg1 = (Dali::WheelEvent *)jarg1;
32398   arg2 = (int)jarg2;
32399   if (arg1) (arg1)->z = arg2;
32400 }
32401
32402
32403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32404   int jresult ;
32405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32406   int result;
32407
32408   arg1 = (Dali::WheelEvent *)jarg1;
32409   result = (int) ((arg1)->z);
32410   jresult = result;
32411   return jresult;
32412 }
32413
32414
32415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32417   unsigned int arg2 ;
32418
32419   arg1 = (Dali::WheelEvent *)jarg1;
32420   arg2 = (unsigned int)jarg2;
32421   if (arg1) (arg1)->timeStamp = arg2;
32422 }
32423
32424
32425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32426   unsigned int jresult ;
32427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32428   unsigned int result;
32429
32430   arg1 = (Dali::WheelEvent *)jarg1;
32431   result = (unsigned int) ((arg1)->timeStamp);
32432   jresult = result;
32433   return jresult;
32434 }
32435
32436 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32437   char * jresult ;
32438   Dali::KeyEvent *arg1 = 0 ;
32439   std::string result;
32440
32441   arg1 = (Dali::KeyEvent *)jarg1;
32442   if (!arg1) {
32443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32444     return 0;
32445   }
32446   {
32447     try {
32448       result = arg1->GetDeviceName();
32449     } catch (std::out_of_range& e) {
32450       {
32451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32452       };
32453     } catch (std::exception& e) {
32454       {
32455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32456       };
32457     } catch (Dali::DaliException e) {
32458       {
32459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32460       };
32461     } catch (...) {
32462       {
32463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32464       };
32465     }
32466   }
32467
32468   jresult = SWIG_csharp_string_callback((&result)->c_str());
32469   return jresult;
32470 }
32471
32472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32473   int jresult ;
32474   Dali::KeyEvent *arg1 = 0 ;
32475   Dali::Device::Class::Type result;
32476
32477   arg1 = (Dali::KeyEvent *)jarg1;
32478   if (!arg1) {
32479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32480     return 0;
32481   }
32482   {
32483     try {
32484       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32485     } catch (std::out_of_range& e) {
32486       {
32487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32488       };
32489     } catch (std::exception& e) {
32490       {
32491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32492       };
32493     } catch (Dali::DaliException e) {
32494       {
32495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32496       };
32497     } catch (...) {
32498       {
32499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32500       };
32501     }
32502   }
32503
32504   jresult = (int)result;
32505   return jresult;
32506 }
32507
32508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32509   int jresult ;
32510   Dali::KeyEvent *arg1 = 0 ;
32511   Dali::Device::Subclass::Type result;
32512
32513   arg1 = (Dali::KeyEvent *)jarg1;
32514   if (!arg1) {
32515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32516     return 0;
32517   }
32518   {
32519     try {
32520       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32521     } catch (std::out_of_range& e) {
32522       {
32523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32524       };
32525     } catch (std::exception& e) {
32526       {
32527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32528       };
32529     } catch (Dali::DaliException e) {
32530       {
32531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32532       };
32533     } catch (...) {
32534       {
32535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32536       };
32537     }
32538   }
32539
32540   jresult = (int)result;
32541   return jresult;
32542 }
32543
32544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32545   Dali::Actor arg1 ;
32546   Dali::Actor *argp1 ;
32547
32548   argp1 = (Dali::Actor *)jarg1;
32549   if (!argp1) {
32550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32551     return ;
32552   }
32553   arg1 = *argp1;
32554   {
32555     try {
32556       arg1.Raise();
32557     } catch (std::out_of_range& e) {
32558       {
32559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32560       };
32561     } catch (std::exception& e) {
32562       {
32563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32564       };
32565     } catch (Dali::DaliException e) {
32566       {
32567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32568       };
32569     } catch (...) {
32570       {
32571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32572       };
32573     }
32574   }
32575
32576 }
32577
32578
32579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32580   Dali::Actor arg1 ;
32581   Dali::Actor *argp1 ;
32582
32583   argp1 = (Dali::Actor *)jarg1;
32584   if (!argp1) {
32585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32586     return ;
32587   }
32588   arg1 = *argp1;
32589   {
32590     try {
32591       arg1.Lower();
32592     } catch (std::out_of_range& e) {
32593       {
32594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32595       };
32596     } catch (std::exception& e) {
32597       {
32598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32599       };
32600     } catch (Dali::DaliException e) {
32601       {
32602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32603       };
32604     } catch (...) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32607       };
32608     }
32609   }
32610
32611 }
32612
32613
32614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32615   Dali::Actor arg1 ;
32616   Dali::Actor *argp1 ;
32617
32618   argp1 = (Dali::Actor *)jarg1;
32619   if (!argp1) {
32620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32621     return ;
32622   }
32623   arg1 = *argp1;
32624   {
32625     try {
32626       arg1.RaiseToTop();
32627     } catch (std::out_of_range& e) {
32628       {
32629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (std::exception& e) {
32632       {
32633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32634       };
32635     } catch (Dali::DaliException e) {
32636       {
32637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32638       };
32639     } catch (...) {
32640       {
32641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32642       };
32643     }
32644   }
32645
32646 }
32647
32648
32649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32650   Dali::Actor arg1 ;
32651   Dali::Actor *argp1 ;
32652
32653   argp1 = (Dali::Actor *)jarg1;
32654   if (!argp1) {
32655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32656     return ;
32657   }
32658   arg1 = *argp1;
32659   {
32660     try {
32661       arg1.LowerToBottom();
32662     } catch (std::out_of_range& e) {
32663       {
32664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (std::exception& e) {
32667       {
32668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32669       };
32670     } catch (Dali::DaliException e) {
32671       {
32672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32673       };
32674     } catch (...) {
32675       {
32676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32677       };
32678     }
32679   }
32680
32681 }
32682
32683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32684   Dali::Actor arg1 ;
32685   Dali::Actor arg2 ;
32686   Dali::Actor *argp1 ;
32687   Dali::Actor *argp2 ;
32688
32689   argp1 = (Dali::Actor *)jarg1;
32690   if (!argp1) {
32691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32692     return ;
32693   }
32694   arg1 = *argp1;
32695   argp2 = (Dali::Actor *)jarg2;
32696   if (!argp2) {
32697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32698     return ;
32699   }
32700   arg2 = *argp2;
32701   {
32702     try {
32703       arg1.RaiseAbove(arg2);
32704     } catch (std::out_of_range& e) {
32705       {
32706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32707       };
32708     } catch (std::exception& e) {
32709       {
32710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32711       };
32712     } catch (Dali::DaliException e) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32715       };
32716     } catch (...) {
32717       {
32718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32719       };
32720     }
32721   }
32722
32723 }
32724
32725
32726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32727   Dali::Actor arg1 ;
32728   Dali::Actor arg2 ;
32729   Dali::Actor *argp1 ;
32730   Dali::Actor *argp2 ;
32731
32732   argp1 = (Dali::Actor *)jarg1;
32733   if (!argp1) {
32734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32735     return ;
32736   }
32737   arg1 = *argp1;
32738   argp2 = (Dali::Actor *)jarg2;
32739   if (!argp2) {
32740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32741     return ;
32742   }
32743   arg2 = *argp2;
32744   {
32745     try {
32746       arg1.LowerBelow(arg2);
32747     } catch (std::out_of_range& e) {
32748       {
32749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32750       };
32751     } catch (std::exception& e) {
32752       {
32753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32754       };
32755     } catch (Dali::DaliException e) {
32756       {
32757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32758       };
32759     } catch (...) {
32760       {
32761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32762       };
32763     }
32764   }
32765
32766 }
32767
32768
32769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32770   void * jresult ;
32771   Dali::Actor arg1 ;
32772   Dali::Actor *argp1 ;
32773   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32774
32775   argp1 = (Dali::Actor *)jarg1;
32776   if (!argp1) {
32777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32778     return 0;
32779   }
32780   arg1 = *argp1;
32781   {
32782     try {
32783       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32784     } catch (std::out_of_range& e) {
32785       {
32786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32787       };
32788     } catch (std::exception& e) {
32789       {
32790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32791       };
32792     } catch (Dali::DaliException e) {
32793       {
32794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32795       };
32796     } catch (...) {
32797       {
32798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32799       };
32800     }
32801   }
32802
32803   jresult = (void *)result;
32804   return jresult;
32805 }
32806
32807
32808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32809   void * jresult ;
32810   Dali::Actor *arg1 ;
32811   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32812
32813   arg1 = (Dali::Actor *)jarg1;
32814   {
32815     try {
32816       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32817     } catch (std::out_of_range& e) {
32818       {
32819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32820       };
32821     } catch (std::exception& e) {
32822       {
32823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32824       };
32825     } catch (Dali::DaliException e) {
32826       {
32827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32828       };
32829     } catch (...) {
32830       {
32831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32832       };
32833     }
32834   }
32835
32836   jresult = (void *)result;
32837   return jresult;
32838 }
32839
32840
32841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32842   int jresult ;
32843   int result;
32844
32845   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32846   jresult = (int)result;
32847   return jresult;
32848 }
32849
32850
32851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32852   int jresult ;
32853   int result;
32854
32855   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32856   jresult = (int)result;
32857   return jresult;
32858 }
32859
32860
32861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32862   int jresult ;
32863   int result;
32864
32865   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32866   jresult = (int)result;
32867   return jresult;
32868 }
32869
32870
32871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32872   int jresult ;
32873   int result;
32874
32875   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32876   jresult = (int)result;
32877   return jresult;
32878 }
32879
32880
32881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32882   int jresult ;
32883   int result;
32884
32885   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32886   jresult = (int)result;
32887   return jresult;
32888 }
32889
32890
32891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32892   int jresult ;
32893   int result;
32894
32895   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32896   jresult = (int)result;
32897   return jresult;
32898 }
32899
32900
32901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32902   int jresult ;
32903   int result;
32904
32905   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32906   jresult = (int)result;
32907   return jresult;
32908 }
32909
32910
32911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32912   int jresult ;
32913   int result;
32914
32915   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32916   jresult = (int)result;
32917   return jresult;
32918 }
32919
32920
32921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32922   int jresult ;
32923   int result;
32924
32925   result = (int)Dali::Actor::Property::SIZE;
32926   jresult = (int)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::POSITION;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::POSITION_X;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::POSITION_Y;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::POSITION_Z;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::WORLD_POSITION;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::ORIENTATION;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::SCALE;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::SCALE_X;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::SCALE_Y;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::SCALE_Z;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WORLD_SCALE;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::VISIBLE;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::COLOR;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::COLOR_RED;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::COLOR_GREEN;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::COLOR_BLUE;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::WORLD_COLOR;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::NAME;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::SENSITIVE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::COLOR_MODE;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::DRAW_MODE;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::PADDING;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33372   void * jresult ;
33373   Dali::Actor::Property *result = 0 ;
33374
33375   {
33376     try {
33377       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33378     } catch (std::out_of_range& e) {
33379       {
33380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33381       };
33382     } catch (std::exception& e) {
33383       {
33384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33385       };
33386     } catch (Dali::DaliException e) {
33387       {
33388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33389       };
33390     } catch (...) {
33391       {
33392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33393       };
33394     }
33395   }
33396
33397   jresult = (void *)result;
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33403   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33404
33405   arg1 = (Dali::Actor::Property *)jarg1;
33406   {
33407     try {
33408       delete arg1;
33409     } catch (std::out_of_range& e) {
33410       {
33411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33412       };
33413     } catch (std::exception& e) {
33414       {
33415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33416       };
33417     } catch (Dali::DaliException e) {
33418       {
33419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33420       };
33421     } catch (...) {
33422       {
33423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33424       };
33425     }
33426   }
33427
33428 }
33429
33430
33431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33432   void * jresult ;
33433   Dali::Actor *result = 0 ;
33434
33435   {
33436     try {
33437       result = (Dali::Actor *)new Dali::Actor();
33438     } catch (std::out_of_range& e) {
33439       {
33440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33441       };
33442     } catch (std::exception& e) {
33443       {
33444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33445       };
33446     } catch (Dali::DaliException e) {
33447       {
33448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33449       };
33450     } catch (...) {
33451       {
33452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33453       };
33454     }
33455   }
33456
33457   jresult = (void *)result;
33458   return jresult;
33459 }
33460
33461
33462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33463   void * jresult ;
33464   Dali::Actor result;
33465
33466   {
33467     try {
33468       result = Dali::Actor::New();
33469     } catch (std::out_of_range& e) {
33470       {
33471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33472       };
33473     } catch (std::exception& e) {
33474       {
33475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33476       };
33477     } catch (Dali::DaliException e) {
33478       {
33479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33484       };
33485     }
33486   }
33487
33488   jresult = new Dali::Actor((const Dali::Actor &)result);
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33494   void * jresult ;
33495   Dali::BaseHandle arg1 ;
33496   Dali::BaseHandle *argp1 ;
33497   Dali::Actor result;
33498
33499   argp1 = (Dali::BaseHandle *)jarg1;
33500   if (!argp1) {
33501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33502     return 0;
33503   }
33504   arg1 = *argp1;
33505   {
33506     try {
33507       result = Dali::Actor::DownCast(arg1);
33508     } catch (std::out_of_range& e) {
33509       {
33510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33511       };
33512     } catch (std::exception& e) {
33513       {
33514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33515       };
33516     } catch (Dali::DaliException e) {
33517       {
33518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33519       };
33520     } catch (...) {
33521       {
33522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33523       };
33524     }
33525   }
33526
33527   jresult = new Dali::Actor((const Dali::Actor &)result);
33528   return jresult;
33529 }
33530
33531
33532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33533   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33534
33535   arg1 = (Dali::Actor *)jarg1;
33536   {
33537     try {
33538       delete arg1;
33539     } catch (std::out_of_range& e) {
33540       {
33541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33542       };
33543     } catch (std::exception& e) {
33544       {
33545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33546       };
33547     } catch (Dali::DaliException e) {
33548       {
33549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33550       };
33551     } catch (...) {
33552       {
33553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33554       };
33555     }
33556   }
33557
33558 }
33559
33560
33561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33562   void * jresult ;
33563   Dali::Actor *arg1 = 0 ;
33564   Dali::Actor *result = 0 ;
33565
33566   arg1 = (Dali::Actor *)jarg1;
33567   if (!arg1) {
33568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33569     return 0;
33570   }
33571   {
33572     try {
33573       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33574     } catch (std::out_of_range& e) {
33575       {
33576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33577       };
33578     } catch (std::exception& e) {
33579       {
33580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33581       };
33582     } catch (Dali::DaliException e) {
33583       {
33584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33585       };
33586     } catch (...) {
33587       {
33588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33589       };
33590     }
33591   }
33592
33593   jresult = (void *)result;
33594   return jresult;
33595 }
33596
33597
33598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33599   void * jresult ;
33600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33601   Dali::Actor *arg2 = 0 ;
33602   Dali::Actor *result = 0 ;
33603
33604   arg1 = (Dali::Actor *)jarg1;
33605   arg2 = (Dali::Actor *)jarg2;
33606   if (!arg2) {
33607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33608     return 0;
33609   }
33610   {
33611     try {
33612       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33613     } catch (std::out_of_range& e) {
33614       {
33615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33616       };
33617     } catch (std::exception& e) {
33618       {
33619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33620       };
33621     } catch (Dali::DaliException e) {
33622       {
33623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33624       };
33625     } catch (...) {
33626       {
33627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33628       };
33629     }
33630   }
33631
33632   jresult = (void *)result;
33633   return jresult;
33634 }
33635
33636
33637 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33638   char * jresult ;
33639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33640   std::string *result = 0 ;
33641
33642   arg1 = (Dali::Actor *)jarg1;
33643   {
33644     try {
33645       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33646     } catch (std::out_of_range& e) {
33647       {
33648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33649       };
33650     } catch (std::exception& e) {
33651       {
33652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33653       };
33654     } catch (Dali::DaliException e) {
33655       {
33656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33657       };
33658     } catch (...) {
33659       {
33660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33661       };
33662     }
33663   }
33664
33665   jresult = SWIG_csharp_string_callback(result->c_str());
33666   return jresult;
33667 }
33668
33669
33670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33672   std::string *arg2 = 0 ;
33673
33674   arg1 = (Dali::Actor *)jarg1;
33675   if (!jarg2) {
33676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33677     return ;
33678   }
33679   std::string arg2_str(jarg2);
33680   arg2 = &arg2_str;
33681   {
33682     try {
33683       (arg1)->SetName((std::string const &)*arg2);
33684     } catch (std::out_of_range& e) {
33685       {
33686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33687       };
33688     } catch (std::exception& e) {
33689       {
33690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33691       };
33692     } catch (Dali::DaliException e) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33695       };
33696     } catch (...) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33699       };
33700     }
33701   }
33702
33703
33704   //argout typemap for const std::string&
33705
33706 }
33707
33708
33709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33710   unsigned int jresult ;
33711   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33712   unsigned int result;
33713
33714   arg1 = (Dali::Actor *)jarg1;
33715   {
33716     try {
33717       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33718     } catch (std::out_of_range& e) {
33719       {
33720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33721       };
33722     } catch (std::exception& e) {
33723       {
33724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33725       };
33726     } catch (Dali::DaliException e) {
33727       {
33728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33733       };
33734     }
33735   }
33736
33737   jresult = result;
33738   return jresult;
33739 }
33740
33741
33742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33743   unsigned int jresult ;
33744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33745   bool result;
33746
33747   arg1 = (Dali::Actor *)jarg1;
33748   {
33749     try {
33750       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33751     } catch (std::out_of_range& e) {
33752       {
33753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33754       };
33755     } catch (std::exception& e) {
33756       {
33757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33758       };
33759     } catch (Dali::DaliException e) {
33760       {
33761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33762       };
33763     } catch (...) {
33764       {
33765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33766       };
33767     }
33768   }
33769
33770   jresult = result;
33771   return jresult;
33772 }
33773
33774
33775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33776   unsigned int jresult ;
33777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33778   bool result;
33779
33780   arg1 = (Dali::Actor *)jarg1;
33781   {
33782     try {
33783       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33784     } catch (std::out_of_range& e) {
33785       {
33786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33787       };
33788     } catch (std::exception& e) {
33789       {
33790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33791       };
33792     } catch (Dali::DaliException e) {
33793       {
33794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33795       };
33796     } catch (...) {
33797       {
33798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33799       };
33800     }
33801   }
33802
33803   jresult = result;
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33809   unsigned int jresult ;
33810   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33811   bool result;
33812
33813   arg1 = (Dali::Actor *)jarg1;
33814   {
33815     try {
33816       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33817     } catch (std::out_of_range& e) {
33818       {
33819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33820       };
33821     } catch (std::exception& e) {
33822       {
33823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (Dali::DaliException e) {
33826       {
33827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33828       };
33829     } catch (...) {
33830       {
33831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33832       };
33833     }
33834   }
33835
33836   jresult = result;
33837   return jresult;
33838 }
33839
33840
33841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33842   void * jresult ;
33843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33844   Dali::Layer result;
33845
33846   arg1 = (Dali::Actor *)jarg1;
33847   {
33848     try {
33849       result = (arg1)->GetLayer();
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (Dali::DaliException e) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33861       };
33862     } catch (...) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33865       };
33866     }
33867   }
33868
33869   jresult = new Dali::Layer((const Dali::Layer &)result);
33870   return jresult;
33871 }
33872
33873
33874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33876   Dali::Actor arg2 ;
33877   Dali::Actor *argp2 ;
33878
33879   arg1 = (Dali::Actor *)jarg1;
33880   argp2 = (Dali::Actor *)jarg2;
33881   if (!argp2) {
33882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33883     return ;
33884   }
33885   arg2 = *argp2;
33886   {
33887     try {
33888       (arg1)->Add(arg2);
33889     } catch (std::out_of_range& e) {
33890       {
33891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33892       };
33893     } catch (std::exception& e) {
33894       {
33895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33896       };
33897     } catch (Dali::DaliException e) {
33898       {
33899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33900       };
33901     } catch (...) {
33902       {
33903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33904       };
33905     }
33906   }
33907
33908 }
33909
33910
33911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33913   Dali::Actor arg2 ;
33914   Dali::Actor *argp2 ;
33915
33916   arg1 = (Dali::Actor *)jarg1;
33917   argp2 = (Dali::Actor *)jarg2;
33918   if (!argp2) {
33919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33920     return ;
33921   }
33922   arg2 = *argp2;
33923   {
33924     try {
33925       (arg1)->Remove(arg2);
33926     } catch (std::out_of_range& e) {
33927       {
33928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33929       };
33930     } catch (std::exception& e) {
33931       {
33932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33933       };
33934     } catch (Dali::DaliException e) {
33935       {
33936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33937       };
33938     } catch (...) {
33939       {
33940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33941       };
33942     }
33943   }
33944
33945 }
33946
33947
33948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33950
33951   arg1 = (Dali::Actor *)jarg1;
33952   {
33953     try {
33954       (arg1)->Unparent();
33955     } catch (std::out_of_range& e) {
33956       {
33957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33958       };
33959     } catch (std::exception& e) {
33960       {
33961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33962       };
33963     } catch (Dali::DaliException e) {
33964       {
33965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33966       };
33967     } catch (...) {
33968       {
33969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33970       };
33971     }
33972   }
33973
33974 }
33975
33976
33977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33978   unsigned int jresult ;
33979   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33980   unsigned int result;
33981
33982   arg1 = (Dali::Actor *)jarg1;
33983   {
33984     try {
33985       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33986     } catch (std::out_of_range& e) {
33987       {
33988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (std::exception& e) {
33991       {
33992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (Dali::DaliException e) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33997       };
33998     } catch (...) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34001       };
34002     }
34003   }
34004
34005   jresult = result;
34006   return jresult;
34007 }
34008
34009
34010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34011   void * jresult ;
34012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34013   unsigned int arg2 ;
34014   Dali::Actor result;
34015
34016   arg1 = (Dali::Actor *)jarg1;
34017   arg2 = (unsigned int)jarg2;
34018   {
34019     try {
34020       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34021     } catch (std::out_of_range& e) {
34022       {
34023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34024       };
34025     } catch (std::exception& e) {
34026       {
34027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34028       };
34029     } catch (Dali::DaliException e) {
34030       {
34031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34032       };
34033     } catch (...) {
34034       {
34035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34036       };
34037     }
34038   }
34039
34040   jresult = new Dali::Actor((const Dali::Actor &)result);
34041   return jresult;
34042 }
34043
34044
34045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34046   void * jresult ;
34047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34048   std::string *arg2 = 0 ;
34049   Dali::Actor result;
34050
34051   arg1 = (Dali::Actor *)jarg1;
34052   if (!jarg2) {
34053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34054     return 0;
34055   }
34056   std::string arg2_str(jarg2);
34057   arg2 = &arg2_str;
34058   {
34059     try {
34060       result = (arg1)->FindChildByName((std::string const &)*arg2);
34061     } catch (std::out_of_range& e) {
34062       {
34063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34064       };
34065     } catch (std::exception& e) {
34066       {
34067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34068       };
34069     } catch (Dali::DaliException e) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34072       };
34073     } catch (...) {
34074       {
34075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34076       };
34077     }
34078   }
34079
34080   jresult = new Dali::Actor((const Dali::Actor &)result);
34081
34082   //argout typemap for const std::string&
34083
34084   return jresult;
34085 }
34086
34087
34088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34089   void * jresult ;
34090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34091   unsigned int arg2 ;
34092   Dali::Actor result;
34093
34094   arg1 = (Dali::Actor *)jarg1;
34095   arg2 = (unsigned int)jarg2;
34096   {
34097     try {
34098       result = (arg1)->FindChildById(arg2);
34099     } catch (std::out_of_range& e) {
34100       {
34101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (std::exception& e) {
34104       {
34105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34106       };
34107     } catch (Dali::DaliException e) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34110       };
34111     } catch (...) {
34112       {
34113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34114       };
34115     }
34116   }
34117
34118   jresult = new Dali::Actor((const Dali::Actor &)result);
34119   return jresult;
34120 }
34121
34122
34123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34124   void * jresult ;
34125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34126   Dali::Actor result;
34127
34128   arg1 = (Dali::Actor *)jarg1;
34129   {
34130     try {
34131       result = ((Dali::Actor const *)arg1)->GetParent();
34132     } catch (std::out_of_range& e) {
34133       {
34134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34135       };
34136     } catch (std::exception& e) {
34137       {
34138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34139       };
34140     } catch (Dali::DaliException e) {
34141       {
34142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34143       };
34144     } catch (...) {
34145       {
34146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34147       };
34148     }
34149   }
34150
34151   jresult = new Dali::Actor((const Dali::Actor &)result);
34152   return jresult;
34153 }
34154
34155
34156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34158   Dali::Vector3 *arg2 = 0 ;
34159
34160   arg1 = (Dali::Actor *)jarg1;
34161   arg2 = (Dali::Vector3 *)jarg2;
34162   if (!arg2) {
34163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34164     return ;
34165   }
34166   {
34167     try {
34168       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34169     } catch (std::out_of_range& e) {
34170       {
34171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34172       };
34173     } catch (std::exception& e) {
34174       {
34175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34176       };
34177     } catch (Dali::DaliException e) {
34178       {
34179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34180       };
34181     } catch (...) {
34182       {
34183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34184       };
34185     }
34186   }
34187
34188 }
34189
34190
34191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34192   void * jresult ;
34193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34194   Dali::Vector3 result;
34195
34196   arg1 = (Dali::Actor *)jarg1;
34197   {
34198     try {
34199       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34200     } catch (std::out_of_range& e) {
34201       {
34202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34203       };
34204     } catch (std::exception& e) {
34205       {
34206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34207       };
34208     } catch (Dali::DaliException e) {
34209       {
34210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34211       };
34212     } catch (...) {
34213       {
34214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34215       };
34216     }
34217   }
34218
34219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34220   return jresult;
34221 }
34222
34223
34224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34226   Dali::Vector3 *arg2 = 0 ;
34227
34228   arg1 = (Dali::Actor *)jarg1;
34229   arg2 = (Dali::Vector3 *)jarg2;
34230   if (!arg2) {
34231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34232     return ;
34233   }
34234   {
34235     try {
34236       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34237     } catch (std::out_of_range& e) {
34238       {
34239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34240       };
34241     } catch (std::exception& e) {
34242       {
34243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34244       };
34245     } catch (Dali::DaliException e) {
34246       {
34247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34248       };
34249     } catch (...) {
34250       {
34251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34252       };
34253     }
34254   }
34255
34256 }
34257
34258
34259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34260   void * jresult ;
34261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34262   Dali::Vector3 result;
34263
34264   arg1 = (Dali::Actor *)jarg1;
34265   {
34266     try {
34267       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (Dali::DaliException e) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34283       };
34284     }
34285   }
34286
34287   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34288   return jresult;
34289 }
34290
34291
34292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34294   float arg2 ;
34295   float arg3 ;
34296
34297   arg1 = (Dali::Actor *)jarg1;
34298   arg2 = (float)jarg2;
34299   arg3 = (float)jarg3;
34300   {
34301     try {
34302       (arg1)->SetSize(arg2,arg3);
34303     } catch (std::out_of_range& e) {
34304       {
34305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34306       };
34307     } catch (std::exception& e) {
34308       {
34309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34310       };
34311     } catch (Dali::DaliException e) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34314       };
34315     } catch (...) {
34316       {
34317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34318       };
34319     }
34320   }
34321
34322 }
34323
34324
34325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34327   float arg2 ;
34328   float arg3 ;
34329   float arg4 ;
34330
34331   arg1 = (Dali::Actor *)jarg1;
34332   arg2 = (float)jarg2;
34333   arg3 = (float)jarg3;
34334   arg4 = (float)jarg4;
34335   {
34336     try {
34337       (arg1)->SetSize(arg2,arg3,arg4);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34345       };
34346     } catch (Dali::DaliException e) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34349       };
34350     } catch (...) {
34351       {
34352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34353       };
34354     }
34355   }
34356
34357 }
34358
34359
34360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34362   Dali::Vector2 *arg2 = 0 ;
34363
34364   arg1 = (Dali::Actor *)jarg1;
34365   arg2 = (Dali::Vector2 *)jarg2;
34366   if (!arg2) {
34367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34368     return ;
34369   }
34370   {
34371     try {
34372       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34373     } catch (std::out_of_range& e) {
34374       {
34375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34376       };
34377     } catch (std::exception& e) {
34378       {
34379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34380       };
34381     } catch (Dali::DaliException e) {
34382       {
34383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34384       };
34385     } catch (...) {
34386       {
34387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34388       };
34389     }
34390   }
34391
34392 }
34393
34394
34395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34397   Dali::Vector3 *arg2 = 0 ;
34398
34399   arg1 = (Dali::Actor *)jarg1;
34400   arg2 = (Dali::Vector3 *)jarg2;
34401   if (!arg2) {
34402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34403     return ;
34404   }
34405   {
34406     try {
34407       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34408     } catch (std::out_of_range& e) {
34409       {
34410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34411       };
34412     } catch (std::exception& e) {
34413       {
34414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34415       };
34416     } catch (Dali::DaliException e) {
34417       {
34418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34419       };
34420     } catch (...) {
34421       {
34422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34423       };
34424     }
34425   }
34426
34427 }
34428
34429
34430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34431   void * jresult ;
34432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34433   Dali::Vector3 result;
34434
34435   arg1 = (Dali::Actor *)jarg1;
34436   {
34437     try {
34438       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34439     } catch (std::out_of_range& e) {
34440       {
34441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34442       };
34443     } catch (std::exception& e) {
34444       {
34445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34446       };
34447     } catch (Dali::DaliException e) {
34448       {
34449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34450       };
34451     } catch (...) {
34452       {
34453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34454       };
34455     }
34456   }
34457
34458   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34459   return jresult;
34460 }
34461
34462
34463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34464   void * jresult ;
34465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34466   Dali::Vector3 result;
34467
34468   arg1 = (Dali::Actor *)jarg1;
34469   {
34470     try {
34471       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34479       };
34480     } catch (Dali::DaliException e) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34483       };
34484     } catch (...) {
34485       {
34486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34487       };
34488     }
34489   }
34490
34491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34492   return jresult;
34493 }
34494
34495
34496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34497   void * jresult ;
34498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34499   Dali::Vector3 result;
34500
34501   arg1 = (Dali::Actor *)jarg1;
34502   {
34503     try {
34504       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34505     } catch (std::out_of_range& e) {
34506       {
34507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34508       };
34509     } catch (std::exception& e) {
34510       {
34511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34512       };
34513     } catch (Dali::DaliException e) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34516       };
34517     } catch (...) {
34518       {
34519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34520       };
34521     }
34522   }
34523
34524   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34525   return jresult;
34526 }
34527
34528
34529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34531   float arg2 ;
34532   float arg3 ;
34533
34534   arg1 = (Dali::Actor *)jarg1;
34535   arg2 = (float)jarg2;
34536   arg3 = (float)jarg3;
34537   {
34538     try {
34539       (arg1)->SetPosition(arg2,arg3);
34540     } catch (std::out_of_range& e) {
34541       {
34542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34543       };
34544     } catch (std::exception& e) {
34545       {
34546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (Dali::DaliException e) {
34549       {
34550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558
34559 }
34560
34561
34562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34564   float arg2 ;
34565   float arg3 ;
34566   float arg4 ;
34567
34568   arg1 = (Dali::Actor *)jarg1;
34569   arg2 = (float)jarg2;
34570   arg3 = (float)jarg3;
34571   arg4 = (float)jarg4;
34572   {
34573     try {
34574       (arg1)->SetPosition(arg2,arg3,arg4);
34575     } catch (std::out_of_range& e) {
34576       {
34577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34578       };
34579     } catch (std::exception& e) {
34580       {
34581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34582       };
34583     } catch (Dali::DaliException e) {
34584       {
34585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34590       };
34591     }
34592   }
34593
34594 }
34595
34596
34597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34599   Dali::Vector3 *arg2 = 0 ;
34600
34601   arg1 = (Dali::Actor *)jarg1;
34602   arg2 = (Dali::Vector3 *)jarg2;
34603   if (!arg2) {
34604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34605     return ;
34606   }
34607   {
34608     try {
34609       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34610     } catch (std::out_of_range& e) {
34611       {
34612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34613       };
34614     } catch (std::exception& e) {
34615       {
34616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34617       };
34618     } catch (Dali::DaliException e) {
34619       {
34620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34621       };
34622     } catch (...) {
34623       {
34624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34625       };
34626     }
34627   }
34628
34629 }
34630
34631
34632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34633   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34634   float arg2 ;
34635
34636   arg1 = (Dali::Actor *)jarg1;
34637   arg2 = (float)jarg2;
34638   {
34639     try {
34640       (arg1)->SetX(arg2);
34641     } catch (std::out_of_range& e) {
34642       {
34643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34644       };
34645     } catch (std::exception& e) {
34646       {
34647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34648       };
34649     } catch (Dali::DaliException e) {
34650       {
34651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34652       };
34653     } catch (...) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34656       };
34657     }
34658   }
34659
34660 }
34661
34662
34663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34664   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34665   float arg2 ;
34666
34667   arg1 = (Dali::Actor *)jarg1;
34668   arg2 = (float)jarg2;
34669   {
34670     try {
34671       (arg1)->SetY(arg2);
34672     } catch (std::out_of_range& e) {
34673       {
34674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34675       };
34676     } catch (std::exception& e) {
34677       {
34678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34679       };
34680     } catch (Dali::DaliException e) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34683       };
34684     } catch (...) {
34685       {
34686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34687       };
34688     }
34689   }
34690
34691 }
34692
34693
34694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34696   float arg2 ;
34697
34698   arg1 = (Dali::Actor *)jarg1;
34699   arg2 = (float)jarg2;
34700   {
34701     try {
34702       (arg1)->SetZ(arg2);
34703     } catch (std::out_of_range& e) {
34704       {
34705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34706       };
34707     } catch (std::exception& e) {
34708       {
34709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34710       };
34711     } catch (Dali::DaliException e) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34714       };
34715     } catch (...) {
34716       {
34717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34718       };
34719     }
34720   }
34721
34722 }
34723
34724
34725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34727   Dali::Vector3 *arg2 = 0 ;
34728
34729   arg1 = (Dali::Actor *)jarg1;
34730   arg2 = (Dali::Vector3 *)jarg2;
34731   if (!arg2) {
34732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34733     return ;
34734   }
34735   {
34736     try {
34737       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34738     } catch (std::out_of_range& e) {
34739       {
34740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34741       };
34742     } catch (std::exception& e) {
34743       {
34744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34745       };
34746     } catch (Dali::DaliException e) {
34747       {
34748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34749       };
34750     } catch (...) {
34751       {
34752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34753       };
34754     }
34755   }
34756
34757 }
34758
34759
34760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34761   void * jresult ;
34762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34763   Dali::Vector3 result;
34764
34765   arg1 = (Dali::Actor *)jarg1;
34766   {
34767     try {
34768       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34769     } catch (std::out_of_range& e) {
34770       {
34771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34772       };
34773     } catch (std::exception& e) {
34774       {
34775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34776       };
34777     } catch (Dali::DaliException e) {
34778       {
34779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34780       };
34781     } catch (...) {
34782       {
34783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34784       };
34785     }
34786   }
34787
34788   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34789   return jresult;
34790 }
34791
34792
34793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34794   void * jresult ;
34795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34796   Dali::Vector3 result;
34797
34798   arg1 = (Dali::Actor *)jarg1;
34799   {
34800     try {
34801       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34802     } catch (std::out_of_range& e) {
34803       {
34804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34805       };
34806     } catch (std::exception& e) {
34807       {
34808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34809       };
34810     } catch (Dali::DaliException e) {
34811       {
34812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34813       };
34814     } catch (...) {
34815       {
34816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34817       };
34818     }
34819   }
34820
34821   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34822   return jresult;
34823 }
34824
34825
34826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34828   bool arg2 ;
34829
34830   arg1 = (Dali::Actor *)jarg1;
34831   arg2 = jarg2 ? true : false;
34832   {
34833     try {
34834       (arg1)->SetInheritPosition(arg2);
34835     } catch (std::out_of_range& e) {
34836       {
34837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34838       };
34839     } catch (std::exception& e) {
34840       {
34841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34842       };
34843     } catch (Dali::DaliException e) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34846       };
34847     } catch (...) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34850       };
34851     }
34852   }
34853
34854 }
34855
34856
34857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34858   unsigned int jresult ;
34859   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34860   bool result;
34861
34862   arg1 = (Dali::Actor *)jarg1;
34863   {
34864     try {
34865       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34866     } catch (std::out_of_range& e) {
34867       {
34868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34869       };
34870     } catch (std::exception& e) {
34871       {
34872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34873       };
34874     } catch (Dali::DaliException e) {
34875       {
34876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34877       };
34878     } catch (...) {
34879       {
34880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34881       };
34882     }
34883   }
34884
34885   jresult = result;
34886   return jresult;
34887 }
34888
34889
34890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34892   Dali::Degree *arg2 = 0 ;
34893   Dali::Vector3 *arg3 = 0 ;
34894
34895   arg1 = (Dali::Actor *)jarg1;
34896   arg2 = (Dali::Degree *)jarg2;
34897   if (!arg2) {
34898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34899     return ;
34900   }
34901   arg3 = (Dali::Vector3 *)jarg3;
34902   if (!arg3) {
34903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34904     return ;
34905   }
34906   {
34907     try {
34908       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34909     } catch (std::out_of_range& e) {
34910       {
34911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34912       };
34913     } catch (std::exception& e) {
34914       {
34915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34916       };
34917     } catch (Dali::DaliException e) {
34918       {
34919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34920       };
34921     } catch (...) {
34922       {
34923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34924       };
34925     }
34926   }
34927
34928 }
34929
34930
34931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34932   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34933   Dali::Radian *arg2 = 0 ;
34934   Dali::Vector3 *arg3 = 0 ;
34935
34936   arg1 = (Dali::Actor *)jarg1;
34937   arg2 = (Dali::Radian *)jarg2;
34938   if (!arg2) {
34939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34940     return ;
34941   }
34942   arg3 = (Dali::Vector3 *)jarg3;
34943   if (!arg3) {
34944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34945     return ;
34946   }
34947   {
34948     try {
34949       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34950     } catch (std::out_of_range& e) {
34951       {
34952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34953       };
34954     } catch (std::exception& e) {
34955       {
34956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34957       };
34958     } catch (Dali::DaliException e) {
34959       {
34960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34961       };
34962     } catch (...) {
34963       {
34964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34965       };
34966     }
34967   }
34968
34969 }
34970
34971
34972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34974   Dali::Quaternion *arg2 = 0 ;
34975
34976   arg1 = (Dali::Actor *)jarg1;
34977   arg2 = (Dali::Quaternion *)jarg2;
34978   if (!arg2) {
34979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34980     return ;
34981   }
34982   {
34983     try {
34984       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34985     } catch (std::out_of_range& e) {
34986       {
34987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34988       };
34989     } catch (std::exception& e) {
34990       {
34991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34992       };
34993     } catch (Dali::DaliException e) {
34994       {
34995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34996       };
34997     } catch (...) {
34998       {
34999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35000       };
35001     }
35002   }
35003
35004 }
35005
35006
35007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35009   Dali::Degree *arg2 = 0 ;
35010   Dali::Vector3 *arg3 = 0 ;
35011
35012   arg1 = (Dali::Actor *)jarg1;
35013   arg2 = (Dali::Degree *)jarg2;
35014   if (!arg2) {
35015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35016     return ;
35017   }
35018   arg3 = (Dali::Vector3 *)jarg3;
35019   if (!arg3) {
35020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35021     return ;
35022   }
35023   {
35024     try {
35025       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35026     } catch (std::out_of_range& e) {
35027       {
35028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35029       };
35030     } catch (std::exception& e) {
35031       {
35032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35033       };
35034     } catch (Dali::DaliException e) {
35035       {
35036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35037       };
35038     } catch (...) {
35039       {
35040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35041       };
35042     }
35043   }
35044
35045 }
35046
35047
35048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35049   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35050   Dali::Radian *arg2 = 0 ;
35051   Dali::Vector3 *arg3 = 0 ;
35052
35053   arg1 = (Dali::Actor *)jarg1;
35054   arg2 = (Dali::Radian *)jarg2;
35055   if (!arg2) {
35056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35057     return ;
35058   }
35059   arg3 = (Dali::Vector3 *)jarg3;
35060   if (!arg3) {
35061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35062     return ;
35063   }
35064   {
35065     try {
35066       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35067     } catch (std::out_of_range& e) {
35068       {
35069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35070       };
35071     } catch (std::exception& e) {
35072       {
35073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35074       };
35075     } catch (Dali::DaliException e) {
35076       {
35077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35078       };
35079     } catch (...) {
35080       {
35081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35082       };
35083     }
35084   }
35085
35086 }
35087
35088
35089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35091   Dali::Quaternion *arg2 = 0 ;
35092
35093   arg1 = (Dali::Actor *)jarg1;
35094   arg2 = (Dali::Quaternion *)jarg2;
35095   if (!arg2) {
35096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35097     return ;
35098   }
35099   {
35100     try {
35101       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35102     } catch (std::out_of_range& e) {
35103       {
35104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35105       };
35106     } catch (std::exception& e) {
35107       {
35108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35109       };
35110     } catch (Dali::DaliException e) {
35111       {
35112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35113       };
35114     } catch (...) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35117       };
35118     }
35119   }
35120
35121 }
35122
35123
35124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35125   void * jresult ;
35126   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35127   Dali::Quaternion result;
35128
35129   arg1 = (Dali::Actor *)jarg1;
35130   {
35131     try {
35132       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35133     } catch (std::out_of_range& e) {
35134       {
35135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35136       };
35137     } catch (std::exception& e) {
35138       {
35139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35140       };
35141     } catch (Dali::DaliException e) {
35142       {
35143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35144       };
35145     } catch (...) {
35146       {
35147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35148       };
35149     }
35150   }
35151
35152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35153   return jresult;
35154 }
35155
35156
35157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35159   bool arg2 ;
35160
35161   arg1 = (Dali::Actor *)jarg1;
35162   arg2 = jarg2 ? true : false;
35163   {
35164     try {
35165       (arg1)->SetInheritOrientation(arg2);
35166     } catch (std::out_of_range& e) {
35167       {
35168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35169       };
35170     } catch (std::exception& e) {
35171       {
35172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35173       };
35174     } catch (Dali::DaliException e) {
35175       {
35176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35177       };
35178     } catch (...) {
35179       {
35180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35181       };
35182     }
35183   }
35184
35185 }
35186
35187
35188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35189   unsigned int jresult ;
35190   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35191   bool result;
35192
35193   arg1 = (Dali::Actor *)jarg1;
35194   {
35195     try {
35196       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35197     } catch (std::out_of_range& e) {
35198       {
35199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35200       };
35201     } catch (std::exception& e) {
35202       {
35203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35204       };
35205     } catch (Dali::DaliException e) {
35206       {
35207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35208       };
35209     } catch (...) {
35210       {
35211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35212       };
35213     }
35214   }
35215
35216   jresult = result;
35217   return jresult;
35218 }
35219
35220
35221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35222   void * jresult ;
35223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35224   Dali::Quaternion result;
35225
35226   arg1 = (Dali::Actor *)jarg1;
35227   {
35228     try {
35229       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35230     } catch (std::out_of_range& e) {
35231       {
35232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35233       };
35234     } catch (std::exception& e) {
35235       {
35236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35237       };
35238     } catch (Dali::DaliException e) {
35239       {
35240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35241       };
35242     } catch (...) {
35243       {
35244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35245       };
35246     }
35247   }
35248
35249   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35250   return jresult;
35251 }
35252
35253
35254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35255   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35256   float arg2 ;
35257
35258   arg1 = (Dali::Actor *)jarg1;
35259   arg2 = (float)jarg2;
35260   {
35261     try {
35262       (arg1)->SetScale(arg2);
35263     } catch (std::out_of_range& e) {
35264       {
35265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35266       };
35267     } catch (std::exception& e) {
35268       {
35269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35270       };
35271     } catch (Dali::DaliException e) {
35272       {
35273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35274       };
35275     } catch (...) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35278       };
35279     }
35280   }
35281
35282 }
35283
35284
35285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   float arg2 ;
35288   float arg3 ;
35289   float arg4 ;
35290
35291   arg1 = (Dali::Actor *)jarg1;
35292   arg2 = (float)jarg2;
35293   arg3 = (float)jarg3;
35294   arg4 = (float)jarg4;
35295   {
35296     try {
35297       (arg1)->SetScale(arg2,arg3,arg4);
35298     } catch (std::out_of_range& e) {
35299       {
35300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35301       };
35302     } catch (std::exception& e) {
35303       {
35304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35305       };
35306     } catch (Dali::DaliException e) {
35307       {
35308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35309       };
35310     } catch (...) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35313       };
35314     }
35315   }
35316
35317 }
35318
35319
35320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35322   Dali::Vector3 *arg2 = 0 ;
35323
35324   arg1 = (Dali::Actor *)jarg1;
35325   arg2 = (Dali::Vector3 *)jarg2;
35326   if (!arg2) {
35327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35328     return ;
35329   }
35330   {
35331     try {
35332       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (Dali::DaliException e) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35344       };
35345     } catch (...) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35348       };
35349     }
35350   }
35351
35352 }
35353
35354
35355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35357   Dali::Vector3 *arg2 = 0 ;
35358
35359   arg1 = (Dali::Actor *)jarg1;
35360   arg2 = (Dali::Vector3 *)jarg2;
35361   if (!arg2) {
35362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35363     return ;
35364   }
35365   {
35366     try {
35367       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35368     } catch (std::out_of_range& e) {
35369       {
35370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35371       };
35372     } catch (std::exception& e) {
35373       {
35374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35375       };
35376     } catch (Dali::DaliException e) {
35377       {
35378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35379       };
35380     } catch (...) {
35381       {
35382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35383       };
35384     }
35385   }
35386
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35391   void * jresult ;
35392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35393   Dali::Vector3 result;
35394
35395   arg1 = (Dali::Actor *)jarg1;
35396   {
35397     try {
35398       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35399     } catch (std::out_of_range& e) {
35400       {
35401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35402       };
35403     } catch (std::exception& e) {
35404       {
35405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35406       };
35407     } catch (Dali::DaliException e) {
35408       {
35409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35410       };
35411     } catch (...) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35414       };
35415     }
35416   }
35417
35418   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35419   return jresult;
35420 }
35421
35422
35423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35424   void * jresult ;
35425   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35426   Dali::Vector3 result;
35427
35428   arg1 = (Dali::Actor *)jarg1;
35429   {
35430     try {
35431       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35432     } catch (std::out_of_range& e) {
35433       {
35434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35435       };
35436     } catch (std::exception& e) {
35437       {
35438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35439       };
35440     } catch (Dali::DaliException e) {
35441       {
35442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35443       };
35444     } catch (...) {
35445       {
35446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35447       };
35448     }
35449   }
35450
35451   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35452   return jresult;
35453 }
35454
35455
35456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35458   bool arg2 ;
35459
35460   arg1 = (Dali::Actor *)jarg1;
35461   arg2 = jarg2 ? true : false;
35462   {
35463     try {
35464       (arg1)->SetInheritScale(arg2);
35465     } catch (std::out_of_range& e) {
35466       {
35467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35468       };
35469     } catch (std::exception& e) {
35470       {
35471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35472       };
35473     } catch (Dali::DaliException e) {
35474       {
35475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35476       };
35477     } catch (...) {
35478       {
35479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35480       };
35481     }
35482   }
35483
35484 }
35485
35486
35487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35488   unsigned int jresult ;
35489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35490   bool result;
35491
35492   arg1 = (Dali::Actor *)jarg1;
35493   {
35494     try {
35495       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35496     } catch (std::out_of_range& e) {
35497       {
35498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35499       };
35500     } catch (std::exception& e) {
35501       {
35502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35503       };
35504     } catch (Dali::DaliException e) {
35505       {
35506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35507       };
35508     } catch (...) {
35509       {
35510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35511       };
35512     }
35513   }
35514
35515   jresult = result;
35516   return jresult;
35517 }
35518
35519
35520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35521   void * jresult ;
35522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35523   Dali::Matrix result;
35524
35525   arg1 = (Dali::Actor *)jarg1;
35526   {
35527     try {
35528       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35529     } catch (std::out_of_range& e) {
35530       {
35531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35532       };
35533     } catch (std::exception& e) {
35534       {
35535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35536       };
35537     } catch (Dali::DaliException e) {
35538       {
35539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35540       };
35541     } catch (...) {
35542       {
35543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35544       };
35545     }
35546   }
35547
35548   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35549   return jresult;
35550 }
35551
35552
35553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35555   bool arg2 ;
35556
35557   arg1 = (Dali::Actor *)jarg1;
35558   arg2 = jarg2 ? true : false;
35559   {
35560     try {
35561       (arg1)->SetVisible(arg2);
35562     } catch (std::out_of_range& e) {
35563       {
35564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35565       };
35566     } catch (std::exception& e) {
35567       {
35568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35569       };
35570     } catch (Dali::DaliException e) {
35571       {
35572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35573       };
35574     } catch (...) {
35575       {
35576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35577       };
35578     }
35579   }
35580
35581 }
35582
35583
35584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35585   unsigned int jresult ;
35586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35587   bool result;
35588
35589   arg1 = (Dali::Actor *)jarg1;
35590   {
35591     try {
35592       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35593     } catch (std::out_of_range& e) {
35594       {
35595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35596       };
35597     } catch (std::exception& e) {
35598       {
35599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35600       };
35601     } catch (Dali::DaliException e) {
35602       {
35603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35604       };
35605     } catch (...) {
35606       {
35607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35608       };
35609     }
35610   }
35611
35612   jresult = result;
35613   return jresult;
35614 }
35615
35616
35617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35619   float arg2 ;
35620
35621   arg1 = (Dali::Actor *)jarg1;
35622   arg2 = (float)jarg2;
35623   {
35624     try {
35625       (arg1)->SetOpacity(arg2);
35626     } catch (std::out_of_range& e) {
35627       {
35628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35629       };
35630     } catch (std::exception& e) {
35631       {
35632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (Dali::DaliException e) {
35635       {
35636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35637       };
35638     } catch (...) {
35639       {
35640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35641       };
35642     }
35643   }
35644
35645 }
35646
35647
35648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35649   float jresult ;
35650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35651   float result;
35652
35653   arg1 = (Dali::Actor *)jarg1;
35654   {
35655     try {
35656       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35657     } catch (std::out_of_range& e) {
35658       {
35659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35660       };
35661     } catch (std::exception& e) {
35662       {
35663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35664       };
35665     } catch (Dali::DaliException e) {
35666       {
35667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35668       };
35669     } catch (...) {
35670       {
35671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35672       };
35673     }
35674   }
35675
35676   jresult = result;
35677   return jresult;
35678 }
35679
35680
35681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35683   Dali::Vector4 *arg2 = 0 ;
35684
35685   arg1 = (Dali::Actor *)jarg1;
35686   arg2 = (Dali::Vector4 *)jarg2;
35687   if (!arg2) {
35688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35689     return ;
35690   }
35691   {
35692     try {
35693       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35694     } catch (std::out_of_range& e) {
35695       {
35696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35697       };
35698     } catch (std::exception& e) {
35699       {
35700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35701       };
35702     } catch (Dali::DaliException e) {
35703       {
35704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35705       };
35706     } catch (...) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35709       };
35710     }
35711   }
35712
35713 }
35714
35715
35716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35717   void * jresult ;
35718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35719   Dali::Vector4 result;
35720
35721   arg1 = (Dali::Actor *)jarg1;
35722   {
35723     try {
35724       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35725     } catch (std::out_of_range& e) {
35726       {
35727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35728       };
35729     } catch (std::exception& e) {
35730       {
35731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35732       };
35733     } catch (Dali::DaliException e) {
35734       {
35735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35736       };
35737     } catch (...) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35740       };
35741     }
35742   }
35743
35744   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35745   return jresult;
35746 }
35747
35748
35749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35751   Dali::ColorMode arg2 ;
35752
35753   arg1 = (Dali::Actor *)jarg1;
35754   arg2 = (Dali::ColorMode)jarg2;
35755   {
35756     try {
35757       (arg1)->SetColorMode(arg2);
35758     } catch (std::out_of_range& e) {
35759       {
35760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35761       };
35762     } catch (std::exception& e) {
35763       {
35764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35765       };
35766     } catch (Dali::DaliException e) {
35767       {
35768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35769       };
35770     } catch (...) {
35771       {
35772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35773       };
35774     }
35775   }
35776
35777 }
35778
35779
35780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35781   int jresult ;
35782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35783   Dali::ColorMode result;
35784
35785   arg1 = (Dali::Actor *)jarg1;
35786   {
35787     try {
35788       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35789     } catch (std::out_of_range& e) {
35790       {
35791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35792       };
35793     } catch (std::exception& e) {
35794       {
35795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35796       };
35797     } catch (Dali::DaliException e) {
35798       {
35799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35800       };
35801     } catch (...) {
35802       {
35803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35804       };
35805     }
35806   }
35807
35808   jresult = (int)result;
35809   return jresult;
35810 }
35811
35812
35813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35814   void * jresult ;
35815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35816   Dali::Vector4 result;
35817
35818   arg1 = (Dali::Actor *)jarg1;
35819   {
35820     try {
35821       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35822     } catch (std::out_of_range& e) {
35823       {
35824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35825       };
35826     } catch (std::exception& e) {
35827       {
35828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35829       };
35830     } catch (Dali::DaliException e) {
35831       {
35832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35833       };
35834     } catch (...) {
35835       {
35836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35837       };
35838     }
35839   }
35840
35841   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35842   return jresult;
35843 }
35844
35845
35846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35847   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35848   Dali::DrawMode::Type arg2 ;
35849
35850   arg1 = (Dali::Actor *)jarg1;
35851   arg2 = (Dali::DrawMode::Type)jarg2;
35852   {
35853     try {
35854       (arg1)->SetDrawMode(arg2);
35855     } catch (std::out_of_range& e) {
35856       {
35857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35858       };
35859     } catch (std::exception& e) {
35860       {
35861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35862       };
35863     } catch (Dali::DaliException e) {
35864       {
35865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35866       };
35867     } catch (...) {
35868       {
35869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35870       };
35871     }
35872   }
35873
35874 }
35875
35876
35877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35878   int jresult ;
35879   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35880   Dali::DrawMode::Type result;
35881
35882   arg1 = (Dali::Actor *)jarg1;
35883   {
35884     try {
35885       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35886     } catch (std::out_of_range& e) {
35887       {
35888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35889       };
35890     } catch (std::exception& e) {
35891       {
35892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35893       };
35894     } catch (Dali::DaliException e) {
35895       {
35896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35897       };
35898     } catch (...) {
35899       {
35900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35901       };
35902     }
35903   }
35904
35905   jresult = (int)result;
35906   return jresult;
35907 }
35908
35909
35910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35912   bool arg2 ;
35913
35914   arg1 = (Dali::Actor *)jarg1;
35915   arg2 = jarg2 ? true : false;
35916   {
35917     try {
35918       (arg1)->SetSensitive(arg2);
35919     } catch (std::out_of_range& e) {
35920       {
35921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35922       };
35923     } catch (std::exception& e) {
35924       {
35925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35926       };
35927     } catch (Dali::DaliException e) {
35928       {
35929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35930       };
35931     } catch (...) {
35932       {
35933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35934       };
35935     }
35936   }
35937
35938 }
35939
35940
35941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35942   unsigned int jresult ;
35943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35944   bool result;
35945
35946   arg1 = (Dali::Actor *)jarg1;
35947   {
35948     try {
35949       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35950     } catch (std::out_of_range& e) {
35951       {
35952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35953       };
35954     } catch (std::exception& e) {
35955       {
35956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35957       };
35958     } catch (Dali::DaliException e) {
35959       {
35960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35961       };
35962     } catch (...) {
35963       {
35964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35965       };
35966     }
35967   }
35968
35969   jresult = result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35975   unsigned int jresult ;
35976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35977   float *arg2 = 0 ;
35978   float *arg3 = 0 ;
35979   float arg4 ;
35980   float arg5 ;
35981   bool result;
35982
35983   arg1 = (Dali::Actor *)jarg1;
35984   arg2 = (float *)jarg2;
35985   arg3 = (float *)jarg3;
35986   arg4 = (float)jarg4;
35987   arg5 = (float)jarg5;
35988   {
35989     try {
35990       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35991     } catch (std::out_of_range& e) {
35992       {
35993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (std::exception& e) {
35996       {
35997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35998       };
35999     } catch (Dali::DaliException e) {
36000       {
36001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36002       };
36003     } catch (...) {
36004       {
36005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36006       };
36007     }
36008   }
36009
36010   jresult = result;
36011   return jresult;
36012 }
36013
36014
36015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36017   bool arg2 ;
36018
36019   arg1 = (Dali::Actor *)jarg1;
36020   arg2 = jarg2 ? true : false;
36021   {
36022     try {
36023       (arg1)->SetLeaveRequired(arg2);
36024     } catch (std::out_of_range& e) {
36025       {
36026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36027       };
36028     } catch (std::exception& e) {
36029       {
36030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36031       };
36032     } catch (Dali::DaliException e) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36035       };
36036     } catch (...) {
36037       {
36038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36039       };
36040     }
36041   }
36042
36043 }
36044
36045
36046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36047   unsigned int jresult ;
36048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36049   bool result;
36050
36051   arg1 = (Dali::Actor *)jarg1;
36052   {
36053     try {
36054       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36055     } catch (std::out_of_range& e) {
36056       {
36057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36058       };
36059     } catch (std::exception& e) {
36060       {
36061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36062       };
36063     } catch (Dali::DaliException e) {
36064       {
36065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36066       };
36067     } catch (...) {
36068       {
36069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36070       };
36071     }
36072   }
36073
36074   jresult = result;
36075   return jresult;
36076 }
36077
36078
36079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36081   bool arg2 ;
36082
36083   arg1 = (Dali::Actor *)jarg1;
36084   arg2 = jarg2 ? true : false;
36085   {
36086     try {
36087       (arg1)->SetKeyboardFocusable(arg2);
36088     } catch (std::out_of_range& e) {
36089       {
36090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36091       };
36092     } catch (std::exception& e) {
36093       {
36094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36095       };
36096     } catch (Dali::DaliException e) {
36097       {
36098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36099       };
36100     } catch (...) {
36101       {
36102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36103       };
36104     }
36105   }
36106
36107 }
36108
36109
36110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36111   unsigned int jresult ;
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool result;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   {
36117     try {
36118       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36119     } catch (std::out_of_range& e) {
36120       {
36121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (std::exception& e) {
36124       {
36125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36126       };
36127     } catch (Dali::DaliException e) {
36128       {
36129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36130       };
36131     } catch (...) {
36132       {
36133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36134       };
36135     }
36136   }
36137
36138   jresult = result;
36139   return jresult;
36140 }
36141
36142
36143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36145   Dali::ResizePolicy::Type arg2 ;
36146   Dali::Dimension::Type arg3 ;
36147
36148   arg1 = (Dali::Actor *)jarg1;
36149   arg2 = (Dali::ResizePolicy::Type)jarg2;
36150   arg3 = (Dali::Dimension::Type)jarg3;
36151   {
36152     try {
36153       (arg1)->SetResizePolicy(arg2,arg3);
36154     } catch (std::out_of_range& e) {
36155       {
36156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36157       };
36158     } catch (std::exception& e) {
36159       {
36160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36161       };
36162     } catch (Dali::DaliException e) {
36163       {
36164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36165       };
36166     } catch (...) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36169       };
36170     }
36171   }
36172
36173 }
36174
36175
36176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36177   int jresult ;
36178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36179   Dali::Dimension::Type arg2 ;
36180   Dali::ResizePolicy::Type result;
36181
36182   arg1 = (Dali::Actor *)jarg1;
36183   arg2 = (Dali::Dimension::Type)jarg2;
36184   {
36185     try {
36186       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36187     } catch (std::out_of_range& e) {
36188       {
36189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36190       };
36191     } catch (std::exception& e) {
36192       {
36193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36194       };
36195     } catch (Dali::DaliException e) {
36196       {
36197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36198       };
36199     } catch (...) {
36200       {
36201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36202       };
36203     }
36204   }
36205
36206   jresult = (int)result;
36207   return jresult;
36208 }
36209
36210
36211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36213   Dali::SizeScalePolicy::Type arg2 ;
36214
36215   arg1 = (Dali::Actor *)jarg1;
36216   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36217   {
36218     try {
36219       (arg1)->SetSizeScalePolicy(arg2);
36220     } catch (std::out_of_range& e) {
36221       {
36222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36223       };
36224     } catch (std::exception& e) {
36225       {
36226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36227       };
36228     } catch (Dali::DaliException e) {
36229       {
36230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36231       };
36232     } catch (...) {
36233       {
36234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36235       };
36236     }
36237   }
36238
36239 }
36240
36241
36242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36243   int jresult ;
36244   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36245   Dali::SizeScalePolicy::Type result;
36246
36247   arg1 = (Dali::Actor *)jarg1;
36248   {
36249     try {
36250       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36251     } catch (std::out_of_range& e) {
36252       {
36253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36254       };
36255     } catch (std::exception& e) {
36256       {
36257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36258       };
36259     } catch (Dali::DaliException e) {
36260       {
36261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36262       };
36263     } catch (...) {
36264       {
36265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36266       };
36267     }
36268   }
36269
36270   jresult = (int)result;
36271   return jresult;
36272 }
36273
36274
36275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36276   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36277   Dali::Vector3 *arg2 = 0 ;
36278
36279   arg1 = (Dali::Actor *)jarg1;
36280   arg2 = (Dali::Vector3 *)jarg2;
36281   if (!arg2) {
36282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36283     return ;
36284   }
36285   {
36286     try {
36287       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36288     } catch (std::out_of_range& e) {
36289       {
36290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36291       };
36292     } catch (std::exception& e) {
36293       {
36294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36295       };
36296     } catch (Dali::DaliException e) {
36297       {
36298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36299       };
36300     } catch (...) {
36301       {
36302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36303       };
36304     }
36305   }
36306
36307 }
36308
36309
36310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36311   void * jresult ;
36312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36313   Dali::Vector3 result;
36314
36315   arg1 = (Dali::Actor *)jarg1;
36316   {
36317     try {
36318       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36319     } catch (std::out_of_range& e) {
36320       {
36321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36322       };
36323     } catch (std::exception& e) {
36324       {
36325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36326       };
36327     } catch (Dali::DaliException e) {
36328       {
36329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36330       };
36331     } catch (...) {
36332       {
36333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36334       };
36335     }
36336   }
36337
36338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36339   return jresult;
36340 }
36341
36342
36343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36344   float jresult ;
36345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36346   float arg2 ;
36347   float result;
36348
36349   arg1 = (Dali::Actor *)jarg1;
36350   arg2 = (float)jarg2;
36351   {
36352     try {
36353       result = (float)(arg1)->GetHeightForWidth(arg2);
36354     } catch (std::out_of_range& e) {
36355       {
36356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36357       };
36358     } catch (std::exception& e) {
36359       {
36360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (Dali::DaliException e) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372
36373   jresult = result;
36374   return jresult;
36375 }
36376
36377
36378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36379   float jresult ;
36380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36381   float arg2 ;
36382   float result;
36383
36384   arg1 = (Dali::Actor *)jarg1;
36385   arg2 = (float)jarg2;
36386   {
36387     try {
36388       result = (float)(arg1)->GetWidthForHeight(arg2);
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (Dali::DaliException e) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36400       };
36401     } catch (...) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36404       };
36405     }
36406   }
36407
36408   jresult = result;
36409   return jresult;
36410 }
36411
36412
36413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36414   float jresult ;
36415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36416   Dali::Dimension::Type arg2 ;
36417   float result;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   arg2 = (Dali::Dimension::Type)jarg2;
36421   {
36422     try {
36423       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36424     } catch (std::out_of_range& e) {
36425       {
36426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36427       };
36428     } catch (std::exception& e) {
36429       {
36430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36431       };
36432     } catch (Dali::DaliException e) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36435       };
36436     } catch (...) {
36437       {
36438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36439       };
36440     }
36441   }
36442
36443   jresult = result;
36444   return jresult;
36445 }
36446
36447
36448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36450   Dali::Padding *arg2 = 0 ;
36451
36452   arg1 = (Dali::Actor *)jarg1;
36453   arg2 = (Dali::Padding *)jarg2;
36454   if (!arg2) {
36455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36456     return ;
36457   }
36458   {
36459     try {
36460       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36461     } catch (std::out_of_range& e) {
36462       {
36463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36464       };
36465     } catch (std::exception& e) {
36466       {
36467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36468       };
36469     } catch (Dali::DaliException e) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36472       };
36473     } catch (...) {
36474       {
36475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36476       };
36477     }
36478   }
36479
36480 }
36481
36482
36483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36485   Dali::Padding *arg2 = 0 ;
36486
36487   arg1 = (Dali::Actor *)jarg1;
36488   arg2 = (Dali::Padding *)jarg2;
36489   if (!arg2) {
36490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36491     return ;
36492   }
36493   {
36494     try {
36495       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36496     } catch (std::out_of_range& e) {
36497       {
36498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36499       };
36500     } catch (std::exception& e) {
36501       {
36502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36503       };
36504     } catch (Dali::DaliException e) {
36505       {
36506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36507       };
36508     } catch (...) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36511       };
36512     }
36513   }
36514
36515 }
36516
36517
36518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36520   Dali::Vector2 *arg2 = 0 ;
36521
36522   arg1 = (Dali::Actor *)jarg1;
36523   arg2 = (Dali::Vector2 *)jarg2;
36524   if (!arg2) {
36525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36526     return ;
36527   }
36528   {
36529     try {
36530       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36531     } catch (std::out_of_range& e) {
36532       {
36533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36534       };
36535     } catch (std::exception& e) {
36536       {
36537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36538       };
36539     } catch (Dali::DaliException e) {
36540       {
36541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36542       };
36543     } catch (...) {
36544       {
36545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36546       };
36547     }
36548   }
36549
36550 }
36551
36552
36553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36554   void * jresult ;
36555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36556   Dali::Vector2 result;
36557
36558   arg1 = (Dali::Actor *)jarg1;
36559   {
36560     try {
36561       result = (arg1)->GetMinimumSize();
36562     } catch (std::out_of_range& e) {
36563       {
36564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (std::exception& e) {
36567       {
36568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36569       };
36570     } catch (Dali::DaliException e) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36573       };
36574     } catch (...) {
36575       {
36576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36577       };
36578     }
36579   }
36580
36581   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36582   return jresult;
36583 }
36584
36585
36586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36588   Dali::Vector2 *arg2 = 0 ;
36589
36590   arg1 = (Dali::Actor *)jarg1;
36591   arg2 = (Dali::Vector2 *)jarg2;
36592   if (!arg2) {
36593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36594     return ;
36595   }
36596   {
36597     try {
36598       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36599     } catch (std::out_of_range& e) {
36600       {
36601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36602       };
36603     } catch (std::exception& e) {
36604       {
36605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36606       };
36607     } catch (Dali::DaliException e) {
36608       {
36609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36610       };
36611     } catch (...) {
36612       {
36613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36614       };
36615     }
36616   }
36617
36618 }
36619
36620
36621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36622   void * jresult ;
36623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36624   Dali::Vector2 result;
36625
36626   arg1 = (Dali::Actor *)jarg1;
36627   {
36628     try {
36629       result = (arg1)->GetMaximumSize();
36630     } catch (std::out_of_range& e) {
36631       {
36632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36633       };
36634     } catch (std::exception& e) {
36635       {
36636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36637       };
36638     } catch (Dali::DaliException e) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36641       };
36642     } catch (...) {
36643       {
36644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36645       };
36646     }
36647   }
36648
36649   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36650   return jresult;
36651 }
36652
36653
36654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36655   int jresult ;
36656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36657   int result;
36658
36659   arg1 = (Dali::Actor *)jarg1;
36660   {
36661     try {
36662       result = (int)(arg1)->GetHierarchyDepth();
36663       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36664       if(parent)
36665       {
36666         const std::string parentName = parent.GetName();
36667         if(parentName.compare("rootAbsoluteLayout") == 0)
36668         {
36669           result -= 1;
36670         }
36671       }
36672     } catch (std::out_of_range& e) {
36673       {
36674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (std::exception& e) {
36677       {
36678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36679       };
36680     } catch (Dali::DaliException e) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36683       };
36684     } catch (...) {
36685       {
36686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36687       };
36688     }
36689   }
36690
36691   jresult = result;
36692   return jresult;
36693 }
36694
36695
36696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36697   unsigned int jresult ;
36698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36699   Dali::Renderer *arg2 = 0 ;
36700   unsigned int result;
36701
36702   arg1 = (Dali::Actor *)jarg1;
36703   arg2 = (Dali::Renderer *)jarg2;
36704   if (!arg2) {
36705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36706     return 0;
36707   }
36708   {
36709     try {
36710       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36711     } catch (std::out_of_range& e) {
36712       {
36713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36714       };
36715     } catch (std::exception& e) {
36716       {
36717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36718       };
36719     } catch (Dali::DaliException e) {
36720       {
36721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36722       };
36723     } catch (...) {
36724       {
36725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36726       };
36727     }
36728   }
36729
36730   jresult = result;
36731   return jresult;
36732 }
36733
36734
36735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36736   unsigned int jresult ;
36737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36738   unsigned int result;
36739
36740   arg1 = (Dali::Actor *)jarg1;
36741   {
36742     try {
36743       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36744     } catch (std::out_of_range& e) {
36745       {
36746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36747       };
36748     } catch (std::exception& e) {
36749       {
36750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36751       };
36752     } catch (Dali::DaliException e) {
36753       {
36754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36755       };
36756     } catch (...) {
36757       {
36758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36759       };
36760     }
36761   }
36762
36763   jresult = result;
36764   return jresult;
36765 }
36766
36767
36768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36769   void * jresult ;
36770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36771   unsigned int arg2 ;
36772   Dali::Renderer result;
36773
36774   arg1 = (Dali::Actor *)jarg1;
36775   arg2 = (unsigned int)jarg2;
36776   {
36777     try {
36778       result = (arg1)->GetRendererAt(arg2);
36779     } catch (std::out_of_range& e) {
36780       {
36781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36782       };
36783     } catch (std::exception& e) {
36784       {
36785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36786       };
36787     } catch (Dali::DaliException e) {
36788       {
36789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36790       };
36791     } catch (...) {
36792       {
36793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36794       };
36795     }
36796   }
36797
36798   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36799   return jresult;
36800 }
36801
36802
36803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36805   Dali::Renderer *arg2 = 0 ;
36806
36807   arg1 = (Dali::Actor *)jarg1;
36808   arg2 = (Dali::Renderer *)jarg2;
36809   if (!arg2) {
36810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36811     return ;
36812   }
36813   {
36814     try {
36815       (arg1)->RemoveRenderer(*arg2);
36816     } catch (std::out_of_range& e) {
36817       {
36818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36819       };
36820     } catch (std::exception& e) {
36821       {
36822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36823       };
36824     } catch (Dali::DaliException e) {
36825       {
36826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36827       };
36828     } catch (...) {
36829       {
36830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36831       };
36832     }
36833   }
36834
36835 }
36836
36837
36838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36840   unsigned int arg2 ;
36841
36842   arg1 = (Dali::Actor *)jarg1;
36843   arg2 = (unsigned int)jarg2;
36844   {
36845     try {
36846       (arg1)->RemoveRenderer(arg2);
36847     } catch (std::out_of_range& e) {
36848       {
36849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36850       };
36851     } catch (std::exception& e) {
36852       {
36853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36854       };
36855     } catch (Dali::DaliException e) {
36856       {
36857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36858       };
36859     } catch (...) {
36860       {
36861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36862       };
36863     }
36864   }
36865
36866 }
36867
36868
36869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36870   void * jresult ;
36871   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36872   Dali::Actor::TouchSignalType *result = 0 ;
36873
36874   arg1 = (Dali::Actor *)jarg1;
36875   {
36876     try {
36877       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36878     } catch (std::out_of_range& e) {
36879       {
36880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36881       };
36882     } catch (std::exception& e) {
36883       {
36884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36885       };
36886     } catch (Dali::DaliException e) {
36887       {
36888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36889       };
36890     } catch (...) {
36891       {
36892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36893       };
36894     }
36895   }
36896
36897   jresult = (void *)result;
36898   return jresult;
36899 }
36900
36901
36902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36903   void * jresult ;
36904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36905   Dali::Actor::TouchDataSignalType *result = 0 ;
36906
36907   arg1 = (Dali::Actor *)jarg1;
36908   {
36909     try {
36910       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36911     } catch (std::out_of_range& e) {
36912       {
36913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36914       };
36915     } catch (std::exception& e) {
36916       {
36917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36918       };
36919     } catch (Dali::DaliException e) {
36920       {
36921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36922       };
36923     } catch (...) {
36924       {
36925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36926       };
36927     }
36928   }
36929
36930   jresult = (void *)result;
36931   return jresult;
36932 }
36933
36934
36935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36936   void * jresult ;
36937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36938   Dali::Actor::HoverSignalType *result = 0 ;
36939
36940   arg1 = (Dali::Actor *)jarg1;
36941   {
36942     try {
36943       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36944     } catch (std::out_of_range& e) {
36945       {
36946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36947       };
36948     } catch (std::exception& e) {
36949       {
36950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36951       };
36952     } catch (Dali::DaliException e) {
36953       {
36954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36955       };
36956     } catch (...) {
36957       {
36958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36959       };
36960     }
36961   }
36962
36963   jresult = (void *)result;
36964   return jresult;
36965 }
36966
36967
36968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36969   void * jresult ;
36970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36971   Dali::Actor::WheelEventSignalType *result = 0 ;
36972
36973   arg1 = (Dali::Actor *)jarg1;
36974   {
36975     try {
36976       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36977     } catch (std::out_of_range& e) {
36978       {
36979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36980       };
36981     } catch (std::exception& e) {
36982       {
36983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36984       };
36985     } catch (Dali::DaliException e) {
36986       {
36987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36988       };
36989     } catch (...) {
36990       {
36991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36992       };
36993     }
36994   }
36995
36996   jresult = (void *)result;
36997   return jresult;
36998 }
36999
37000
37001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37002   void * jresult ;
37003   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37004   Dali::Actor::OnStageSignalType *result = 0 ;
37005
37006   arg1 = (Dali::Actor *)jarg1;
37007   {
37008     try {
37009       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37010     } catch (std::out_of_range& e) {
37011       {
37012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37013       };
37014     } catch (std::exception& e) {
37015       {
37016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37017       };
37018     } catch (Dali::DaliException e) {
37019       {
37020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37021       };
37022     } catch (...) {
37023       {
37024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37025       };
37026     }
37027   }
37028
37029   jresult = (void *)result;
37030   return jresult;
37031 }
37032
37033
37034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37035   void * jresult ;
37036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37037   Dali::Actor::OffStageSignalType *result = 0 ;
37038
37039   arg1 = (Dali::Actor *)jarg1;
37040   {
37041     try {
37042       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37043     } catch (std::out_of_range& e) {
37044       {
37045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37046       };
37047     } catch (std::exception& e) {
37048       {
37049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37050       };
37051     } catch (Dali::DaliException e) {
37052       {
37053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37054       };
37055     } catch (...) {
37056       {
37057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37058       };
37059     }
37060   }
37061
37062   jresult = (void *)result;
37063   return jresult;
37064 }
37065
37066
37067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37068   void * jresult ;
37069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37070   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37071
37072   arg1 = (Dali::Actor *)jarg1;
37073   {
37074     try {
37075       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37076     } catch (std::out_of_range& e) {
37077       {
37078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37079       };
37080     } catch (std::exception& e) {
37081       {
37082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37083       };
37084     } catch (Dali::DaliException e) {
37085       {
37086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37087       };
37088     } catch (...) {
37089       {
37090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37091       };
37092     }
37093   }
37094
37095   jresult = (void *)result;
37096   return jresult;
37097 }
37098
37099
37100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37101   Dali::Actor *arg1 = 0 ;
37102
37103   arg1 = (Dali::Actor *)jarg1;
37104   if (!arg1) {
37105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37106     return ;
37107   }
37108   {
37109     try {
37110       Dali::UnparentAndReset(*arg1);
37111     } catch (std::out_of_range& e) {
37112       {
37113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37114       };
37115     } catch (std::exception& e) {
37116       {
37117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37118       };
37119     } catch (Dali::DaliException e) {
37120       {
37121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37122       };
37123     } catch (...) {
37124       {
37125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37126       };
37127     }
37128   }
37129
37130 }
37131
37132
37133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37134   int jresult ;
37135   int result;
37136
37137   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37138   jresult = (int)result;
37139   return jresult;
37140 }
37141
37142
37143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37144   int jresult ;
37145   int result;
37146
37147   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37148   jresult = (int)result;
37149   return jresult;
37150 }
37151
37152
37153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37154   int jresult ;
37155   int result;
37156
37157   result = (int)Dali::Layer::Property::BEHAVIOR;
37158   jresult = (int)result;
37159   return jresult;
37160 }
37161
37162
37163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37164   void * jresult ;
37165   Dali::Layer::Property *result = 0 ;
37166
37167   {
37168     try {
37169       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37170     } catch (std::out_of_range& e) {
37171       {
37172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37173       };
37174     } catch (std::exception& e) {
37175       {
37176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37177       };
37178     } catch (Dali::DaliException e) {
37179       {
37180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37181       };
37182     } catch (...) {
37183       {
37184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37185       };
37186     }
37187   }
37188
37189   jresult = (void *)result;
37190   return jresult;
37191 }
37192
37193
37194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37195   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37196
37197   arg1 = (Dali::Layer::Property *)jarg1;
37198   {
37199     try {
37200       delete arg1;
37201     } catch (std::out_of_range& e) {
37202       {
37203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37204       };
37205     } catch (std::exception& e) {
37206       {
37207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37208       };
37209     } catch (Dali::DaliException e) {
37210       {
37211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37212       };
37213     } catch (...) {
37214       {
37215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37216       };
37217     }
37218   }
37219
37220 }
37221
37222
37223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37224   void * jresult ;
37225   Dali::Layer *result = 0 ;
37226
37227   {
37228     try {
37229       result = (Dali::Layer *)new Dali::Layer();
37230     } catch (std::out_of_range& e) {
37231       {
37232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37233       };
37234     } catch (std::exception& e) {
37235       {
37236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37237       };
37238     } catch (Dali::DaliException e) {
37239       {
37240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37241       };
37242     } catch (...) {
37243       {
37244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37245       };
37246     }
37247   }
37248
37249   jresult = (void *)result;
37250   return jresult;
37251 }
37252
37253
37254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37255   void * jresult ;
37256   Dali::Layer result;
37257
37258   {
37259     try {
37260       result = Dali::Layer::New();
37261     } catch (std::out_of_range& e) {
37262       {
37263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37264       };
37265     } catch (std::exception& e) {
37266       {
37267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37268       };
37269     } catch (Dali::DaliException e) {
37270       {
37271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37272       };
37273     } catch (...) {
37274       {
37275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37276       };
37277     }
37278   }
37279
37280   jresult = new Dali::Layer((const Dali::Layer &)result);
37281   return jresult;
37282 }
37283
37284
37285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37286   void * jresult ;
37287   Dali::BaseHandle arg1 ;
37288   Dali::BaseHandle *argp1 ;
37289   Dali::Layer result;
37290
37291   argp1 = (Dali::BaseHandle *)jarg1;
37292   if (!argp1) {
37293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37294     return 0;
37295   }
37296   arg1 = *argp1;
37297   {
37298     try {
37299       result = Dali::Layer::DownCast(arg1);
37300     } catch (std::out_of_range& e) {
37301       {
37302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37303       };
37304     } catch (std::exception& e) {
37305       {
37306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37307       };
37308     } catch (Dali::DaliException e) {
37309       {
37310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37311       };
37312     } catch (...) {
37313       {
37314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37315       };
37316     }
37317   }
37318
37319   jresult = new Dali::Layer((const Dali::Layer &)result);
37320   return jresult;
37321 }
37322
37323
37324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37325   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37326
37327   arg1 = (Dali::Layer *)jarg1;
37328   {
37329     try {
37330       delete arg1;
37331     } catch (std::out_of_range& e) {
37332       {
37333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37334       };
37335     } catch (std::exception& e) {
37336       {
37337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37338       };
37339     } catch (Dali::DaliException e) {
37340       {
37341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37342       };
37343     } catch (...) {
37344       {
37345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37346       };
37347     }
37348   }
37349
37350 }
37351
37352
37353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37354   void * jresult ;
37355   Dali::Layer *arg1 = 0 ;
37356   Dali::Layer *result = 0 ;
37357
37358   arg1 = (Dali::Layer *)jarg1;
37359   if (!arg1) {
37360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37361     return 0;
37362   }
37363   {
37364     try {
37365       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37366     } catch (std::out_of_range& e) {
37367       {
37368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37369       };
37370     } catch (std::exception& e) {
37371       {
37372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37373       };
37374     } catch (Dali::DaliException e) {
37375       {
37376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37377       };
37378     } catch (...) {
37379       {
37380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37381       };
37382     }
37383   }
37384
37385   jresult = (void *)result;
37386   return jresult;
37387 }
37388
37389
37390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37391   void * jresult ;
37392   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37393   Dali::Layer *arg2 = 0 ;
37394   Dali::Layer *result = 0 ;
37395
37396   arg1 = (Dali::Layer *)jarg1;
37397   arg2 = (Dali::Layer *)jarg2;
37398   if (!arg2) {
37399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37400     return 0;
37401   }
37402   {
37403     try {
37404       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37405     } catch (std::out_of_range& e) {
37406       {
37407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37408       };
37409     } catch (std::exception& e) {
37410       {
37411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37412       };
37413     } catch (Dali::DaliException e) {
37414       {
37415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37416       };
37417     } catch (...) {
37418       {
37419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37420       };
37421     }
37422   }
37423
37424   jresult = (void *)result;
37425   return jresult;
37426 }
37427
37428
37429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37430   unsigned int jresult ;
37431   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37432   unsigned int result;
37433
37434   arg1 = (Dali::Layer *)jarg1;
37435   {
37436     try {
37437       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37438     } catch (std::out_of_range& e) {
37439       {
37440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37441       };
37442     } catch (std::exception& e) {
37443       {
37444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37445       };
37446     } catch (Dali::DaliException e) {
37447       {
37448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37449       };
37450     } catch (...) {
37451       {
37452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37453       };
37454     }
37455   }
37456
37457   jresult = result;
37458   return jresult;
37459 }
37460
37461
37462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37463   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37464
37465   arg1 = (Dali::Layer *)jarg1;
37466   {
37467     try {
37468       (arg1)->Raise();
37469     } catch (std::out_of_range& e) {
37470       {
37471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37472       };
37473     } catch (std::exception& e) {
37474       {
37475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37476       };
37477     } catch (Dali::DaliException e) {
37478       {
37479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37480       };
37481     } catch (...) {
37482       {
37483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37484       };
37485     }
37486   }
37487
37488 }
37489
37490
37491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37492   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37493
37494   arg1 = (Dali::Layer *)jarg1;
37495   {
37496     try {
37497       (arg1)->Lower();
37498     } catch (std::out_of_range& e) {
37499       {
37500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37501       };
37502     } catch (std::exception& e) {
37503       {
37504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37505       };
37506     } catch (Dali::DaliException e) {
37507       {
37508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37509       };
37510     } catch (...) {
37511       {
37512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37513       };
37514     }
37515   }
37516
37517 }
37518
37519
37520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37521   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37522   Dali::Layer arg2 ;
37523   Dali::Layer *argp2 ;
37524
37525   arg1 = (Dali::Layer *)jarg1;
37526   argp2 = (Dali::Layer *)jarg2;
37527   if (!argp2) {
37528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37529     return ;
37530   }
37531   arg2 = *argp2;
37532   {
37533     try {
37534       (arg1)->RaiseAbove(arg2);
37535     } catch (std::out_of_range& e) {
37536       {
37537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37538       };
37539     } catch (std::exception& e) {
37540       {
37541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37542       };
37543     } catch (Dali::DaliException e) {
37544       {
37545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37546       };
37547     } catch (...) {
37548       {
37549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37550       };
37551     }
37552   }
37553
37554 }
37555
37556
37557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37558   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37559   Dali::Layer arg2 ;
37560   Dali::Layer *argp2 ;
37561
37562   arg1 = (Dali::Layer *)jarg1;
37563   argp2 = (Dali::Layer *)jarg2;
37564   if (!argp2) {
37565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37566     return ;
37567   }
37568   arg2 = *argp2;
37569   {
37570     try {
37571       (arg1)->LowerBelow(arg2);
37572     } catch (std::out_of_range& e) {
37573       {
37574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37575       };
37576     } catch (std::exception& e) {
37577       {
37578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37579       };
37580     } catch (Dali::DaliException e) {
37581       {
37582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37583       };
37584     } catch (...) {
37585       {
37586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37587       };
37588     }
37589   }
37590
37591 }
37592
37593
37594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37595   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37596
37597   arg1 = (Dali::Layer *)jarg1;
37598   {
37599     try {
37600       (arg1)->RaiseToTop();
37601     } catch (std::out_of_range& e) {
37602       {
37603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37604       };
37605     } catch (std::exception& e) {
37606       {
37607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37608       };
37609     } catch (Dali::DaliException e) {
37610       {
37611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37612       };
37613     } catch (...) {
37614       {
37615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37616       };
37617     }
37618   }
37619
37620 }
37621
37622
37623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37624   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37625
37626   arg1 = (Dali::Layer *)jarg1;
37627   {
37628     try {
37629       (arg1)->LowerToBottom();
37630     } catch (std::out_of_range& e) {
37631       {
37632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37633       };
37634     } catch (std::exception& e) {
37635       {
37636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37637       };
37638     } catch (Dali::DaliException e) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37641       };
37642     } catch (...) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37645       };
37646     }
37647   }
37648
37649 }
37650
37651
37652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37654   Dali::Layer arg2 ;
37655   Dali::Layer *argp2 ;
37656
37657   arg1 = (Dali::Layer *)jarg1;
37658   argp2 = (Dali::Layer *)jarg2;
37659   if (!argp2) {
37660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37661     return ;
37662   }
37663   arg2 = *argp2;
37664   {
37665     try {
37666       (arg1)->MoveAbove(arg2);
37667     } catch (std::out_of_range& e) {
37668       {
37669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37670       };
37671     } catch (std::exception& e) {
37672       {
37673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37674       };
37675     } catch (Dali::DaliException e) {
37676       {
37677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37678       };
37679     } catch (...) {
37680       {
37681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37682       };
37683     }
37684   }
37685
37686 }
37687
37688
37689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37690   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37691   Dali::Layer arg2 ;
37692   Dali::Layer *argp2 ;
37693
37694   arg1 = (Dali::Layer *)jarg1;
37695   argp2 = (Dali::Layer *)jarg2;
37696   if (!argp2) {
37697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37698     return ;
37699   }
37700   arg2 = *argp2;
37701   {
37702     try {
37703       (arg1)->MoveBelow(arg2);
37704     } catch (std::out_of_range& e) {
37705       {
37706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37707       };
37708     } catch (std::exception& e) {
37709       {
37710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37711       };
37712     } catch (Dali::DaliException e) {
37713       {
37714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37715       };
37716     } catch (...) {
37717       {
37718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37719       };
37720     }
37721   }
37722
37723 }
37724
37725
37726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37727   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37728   Dali::Layer::Behavior arg2 ;
37729
37730   arg1 = (Dali::Layer *)jarg1;
37731   arg2 = (Dali::Layer::Behavior)jarg2;
37732   {
37733     try {
37734       (arg1)->SetBehavior(arg2);
37735     } catch (std::out_of_range& e) {
37736       {
37737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37738       };
37739     } catch (std::exception& e) {
37740       {
37741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37742       };
37743     } catch (Dali::DaliException e) {
37744       {
37745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37746       };
37747     } catch (...) {
37748       {
37749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37750       };
37751     }
37752   }
37753
37754 }
37755
37756
37757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37758   int jresult ;
37759   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37760   Dali::Layer::Behavior result;
37761
37762   arg1 = (Dali::Layer *)jarg1;
37763   {
37764     try {
37765       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37766     } catch (std::out_of_range& e) {
37767       {
37768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37769       };
37770     } catch (std::exception& e) {
37771       {
37772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37773       };
37774     } catch (Dali::DaliException e) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37777       };
37778     } catch (...) {
37779       {
37780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37781       };
37782     }
37783   }
37784
37785   jresult = (int)result;
37786   return jresult;
37787 }
37788
37789
37790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37791   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37792   bool arg2 ;
37793
37794   arg1 = (Dali::Layer *)jarg1;
37795   arg2 = jarg2 ? true : false;
37796   {
37797     try {
37798       (arg1)->SetClipping(arg2);
37799     } catch (std::out_of_range& e) {
37800       {
37801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37802       };
37803     } catch (std::exception& e) {
37804       {
37805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37806       };
37807     } catch (Dali::DaliException e) {
37808       {
37809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37810       };
37811     } catch (...) {
37812       {
37813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37814       };
37815     }
37816   }
37817
37818 }
37819
37820
37821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37822   unsigned int jresult ;
37823   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37824   bool result;
37825
37826   arg1 = (Dali::Layer *)jarg1;
37827   {
37828     try {
37829       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37830     } catch (std::out_of_range& e) {
37831       {
37832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37833       };
37834     } catch (std::exception& e) {
37835       {
37836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37837       };
37838     } catch (Dali::DaliException e) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37841       };
37842     } catch (...) {
37843       {
37844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37845       };
37846     }
37847   }
37848
37849   jresult = result;
37850   return jresult;
37851 }
37852
37853
37854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37855   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37856   int arg2 ;
37857   int arg3 ;
37858   int arg4 ;
37859   int arg5 ;
37860
37861   arg1 = (Dali::Layer *)jarg1;
37862   arg2 = (int)jarg2;
37863   arg3 = (int)jarg3;
37864   arg4 = (int)jarg4;
37865   arg5 = (int)jarg5;
37866   {
37867     try {
37868       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37869     } catch (std::out_of_range& e) {
37870       {
37871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37872       };
37873     } catch (std::exception& e) {
37874       {
37875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37876       };
37877     } catch (Dali::DaliException e) {
37878       {
37879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37880       };
37881     } catch (...) {
37882       {
37883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37884       };
37885     }
37886   }
37887
37888 }
37889
37890
37891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37892   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37893   Dali::ClippingBox arg2 ;
37894   Dali::ClippingBox *argp2 ;
37895
37896   arg1 = (Dali::Layer *)jarg1;
37897   argp2 = (Dali::ClippingBox *)jarg2;
37898   if (!argp2) {
37899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37900     return ;
37901   }
37902   arg2 = *argp2;
37903   {
37904     try {
37905       (arg1)->SetClippingBox(arg2);
37906     } catch (std::out_of_range& e) {
37907       {
37908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37909       };
37910     } catch (std::exception& e) {
37911       {
37912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37913       };
37914     } catch (Dali::DaliException e) {
37915       {
37916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37917       };
37918     } catch (...) {
37919       {
37920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37921       };
37922     }
37923   }
37924
37925 }
37926
37927
37928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37929   void * jresult ;
37930   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37931   Dali::ClippingBox result;
37932
37933   arg1 = (Dali::Layer *)jarg1;
37934   {
37935     try {
37936       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37937     } catch (std::out_of_range& e) {
37938       {
37939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37940       };
37941     } catch (std::exception& e) {
37942       {
37943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37944       };
37945     } catch (Dali::DaliException e) {
37946       {
37947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37948       };
37949     } catch (...) {
37950       {
37951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37952       };
37953     }
37954   }
37955
37956   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37957   return jresult;
37958 }
37959
37960
37961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37962   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37963   bool arg2 ;
37964
37965   arg1 = (Dali::Layer *)jarg1;
37966   arg2 = jarg2 ? true : false;
37967   {
37968     try {
37969       (arg1)->SetDepthTestDisabled(arg2);
37970     } catch (std::out_of_range& e) {
37971       {
37972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37973       };
37974     } catch (std::exception& e) {
37975       {
37976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37977       };
37978     } catch (Dali::DaliException e) {
37979       {
37980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37981       };
37982     } catch (...) {
37983       {
37984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37985       };
37986     }
37987   }
37988
37989 }
37990
37991
37992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37993   unsigned int jresult ;
37994   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37995   bool result;
37996
37997   arg1 = (Dali::Layer *)jarg1;
37998   {
37999     try {
38000       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38001     } catch (std::out_of_range& e) {
38002       {
38003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38004       };
38005     } catch (std::exception& e) {
38006       {
38007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38008       };
38009     } catch (Dali::DaliException e) {
38010       {
38011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38012       };
38013     } catch (...) {
38014       {
38015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38016       };
38017     }
38018   }
38019
38020   jresult = result;
38021   return jresult;
38022 }
38023
38024
38025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38026   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38027   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38028
38029   arg1 = (Dali::Layer *)jarg1;
38030   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38031   {
38032     try {
38033       (arg1)->SetSortFunction(arg2);
38034     } catch (std::out_of_range& e) {
38035       {
38036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38037       };
38038     } catch (std::exception& e) {
38039       {
38040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38041       };
38042     } catch (Dali::DaliException e) {
38043       {
38044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38045       };
38046     } catch (...) {
38047       {
38048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38049       };
38050     }
38051   }
38052
38053 }
38054
38055
38056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38057   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38058   bool arg2 ;
38059
38060   arg1 = (Dali::Layer *)jarg1;
38061   arg2 = jarg2 ? true : false;
38062   {
38063     try {
38064       (arg1)->SetTouchConsumed(arg2);
38065     } catch (std::out_of_range& e) {
38066       {
38067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38068       };
38069     } catch (std::exception& e) {
38070       {
38071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38072       };
38073     } catch (Dali::DaliException e) {
38074       {
38075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38076       };
38077     } catch (...) {
38078       {
38079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38080       };
38081     }
38082   }
38083
38084 }
38085
38086
38087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38088   unsigned int jresult ;
38089   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38090   bool result;
38091
38092   arg1 = (Dali::Layer *)jarg1;
38093   {
38094     try {
38095       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38096     } catch (std::out_of_range& e) {
38097       {
38098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38099       };
38100     } catch (std::exception& e) {
38101       {
38102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38103       };
38104     } catch (Dali::DaliException e) {
38105       {
38106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38107       };
38108     } catch (...) {
38109       {
38110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38111       };
38112     }
38113   }
38114
38115   jresult = result;
38116   return jresult;
38117 }
38118
38119
38120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38121   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38122   bool arg2 ;
38123
38124   arg1 = (Dali::Layer *)jarg1;
38125   arg2 = jarg2 ? true : false;
38126   {
38127     try {
38128       (arg1)->SetHoverConsumed(arg2);
38129     } catch (std::out_of_range& e) {
38130       {
38131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38132       };
38133     } catch (std::exception& e) {
38134       {
38135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38136       };
38137     } catch (Dali::DaliException e) {
38138       {
38139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38140       };
38141     } catch (...) {
38142       {
38143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38144       };
38145     }
38146   }
38147
38148 }
38149
38150
38151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38152   unsigned int jresult ;
38153   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38154   bool result;
38155
38156   arg1 = (Dali::Layer *)jarg1;
38157   {
38158     try {
38159       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38160     } catch (std::out_of_range& e) {
38161       {
38162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38163       };
38164     } catch (std::exception& e) {
38165       {
38166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38167       };
38168     } catch (Dali::DaliException e) {
38169       {
38170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38171       };
38172     } catch (...) {
38173       {
38174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38175       };
38176     }
38177   }
38178
38179   jresult = result;
38180   return jresult;
38181 }
38182
38183
38184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38185   void * jresult ;
38186   Dali::Vector4 *result = 0 ;
38187
38188   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38189   jresult = (void *)result;
38190   return jresult;
38191 }
38192
38193
38194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38195   void * jresult ;
38196   Dali::Vector4 *result = 0 ;
38197
38198   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38199   jresult = (void *)result;
38200   return jresult;
38201 }
38202
38203
38204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38205   void * jresult ;
38206   Dali::Stage *result = 0 ;
38207
38208   {
38209     try {
38210       result = (Dali::Stage *)new Dali::Stage();
38211     } catch (std::out_of_range& e) {
38212       {
38213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38214       };
38215     } catch (std::exception& e) {
38216       {
38217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38218       };
38219     } catch (Dali::DaliException e) {
38220       {
38221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38222       };
38223     } catch (...) {
38224       {
38225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38226       };
38227     }
38228   }
38229
38230   jresult = (void *)result;
38231   return jresult;
38232 }
38233
38234
38235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38236   void * jresult ;
38237   Dali::Stage result;
38238
38239   {
38240     try {
38241       result = Dali::Stage::GetCurrent();
38242     } catch (std::out_of_range& e) {
38243       {
38244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38245       };
38246     } catch (std::exception& e) {
38247       {
38248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38249       };
38250     } catch (Dali::DaliException e) {
38251       {
38252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38253       };
38254     } catch (...) {
38255       {
38256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38257       };
38258     }
38259   }
38260
38261   jresult = new Dali::Stage((const Dali::Stage &)result);
38262   return jresult;
38263 }
38264
38265
38266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38267   unsigned int jresult ;
38268   bool result;
38269
38270   {
38271     try {
38272       result = (bool)Dali::Stage::IsInstalled();
38273     } catch (std::out_of_range& e) {
38274       {
38275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38276       };
38277     } catch (std::exception& e) {
38278       {
38279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38280       };
38281     } catch (Dali::DaliException e) {
38282       {
38283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38284       };
38285     } catch (...) {
38286       {
38287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38288       };
38289     }
38290   }
38291
38292   jresult = result;
38293   return jresult;
38294 }
38295
38296
38297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38298   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38299
38300   arg1 = (Dali::Stage *)jarg1;
38301   {
38302     try {
38303       delete arg1;
38304     } catch (std::out_of_range& e) {
38305       {
38306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38307       };
38308     } catch (std::exception& e) {
38309       {
38310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38311       };
38312     } catch (Dali::DaliException e) {
38313       {
38314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38315       };
38316     } catch (...) {
38317       {
38318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38319       };
38320     }
38321   }
38322
38323 }
38324
38325
38326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38327   void * jresult ;
38328   Dali::Stage *arg1 = 0 ;
38329   Dali::Stage *result = 0 ;
38330
38331   arg1 = (Dali::Stage *)jarg1;
38332   if (!arg1) {
38333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38334     return 0;
38335   }
38336   {
38337     try {
38338       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38339     } catch (std::out_of_range& e) {
38340       {
38341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38342       };
38343     } catch (std::exception& e) {
38344       {
38345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38346       };
38347     } catch (Dali::DaliException e) {
38348       {
38349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38350       };
38351     } catch (...) {
38352       {
38353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38354       };
38355     }
38356   }
38357
38358   jresult = (void *)result;
38359   return jresult;
38360 }
38361
38362
38363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38364   void * jresult ;
38365   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38366   Dali::Stage *arg2 = 0 ;
38367   Dali::Stage *result = 0 ;
38368
38369   arg1 = (Dali::Stage *)jarg1;
38370   arg2 = (Dali::Stage *)jarg2;
38371   if (!arg2) {
38372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38373     return 0;
38374   }
38375   {
38376     try {
38377       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38378     } catch (std::out_of_range& e) {
38379       {
38380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38381       };
38382     } catch (std::exception& e) {
38383       {
38384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38385       };
38386     } catch (Dali::DaliException e) {
38387       {
38388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38389       };
38390     } catch (...) {
38391       {
38392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38393       };
38394     }
38395   }
38396
38397   jresult = (void *)result;
38398   return jresult;
38399 }
38400
38401
38402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38403   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38404   Dali::Actor *arg2 = 0 ;
38405
38406   arg1 = (Dali::Stage *)jarg1;
38407   arg2 = (Dali::Actor *)jarg2;
38408   if (!arg2) {
38409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38410     return ;
38411   }
38412   {
38413     try {
38414       (arg1)->Add(*arg2);
38415     } catch (std::out_of_range& e) {
38416       {
38417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38418       };
38419     } catch (std::exception& e) {
38420       {
38421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38422       };
38423     } catch (Dali::DaliException e) {
38424       {
38425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38426       };
38427     } catch (...) {
38428       {
38429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38430       };
38431     }
38432   }
38433
38434 }
38435
38436
38437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38438   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38439   Dali::Actor *arg2 = 0 ;
38440
38441   arg1 = (Dali::Stage *)jarg1;
38442   arg2 = (Dali::Actor *)jarg2;
38443   if (!arg2) {
38444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38445     return ;
38446   }
38447   {
38448     try {
38449       (arg1)->Remove(*arg2);
38450     } catch (std::out_of_range& e) {
38451       {
38452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38453       };
38454     } catch (std::exception& e) {
38455       {
38456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38457       };
38458     } catch (Dali::DaliException e) {
38459       {
38460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38461       };
38462     } catch (...) {
38463       {
38464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38465       };
38466     }
38467   }
38468
38469 }
38470
38471
38472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38473   void * jresult ;
38474   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38475   Dali::Vector2 result;
38476
38477   arg1 = (Dali::Stage *)jarg1;
38478   {
38479     try {
38480       result = ((Dali::Stage const *)arg1)->GetSize();
38481     } catch (std::out_of_range& e) {
38482       {
38483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38484       };
38485     } catch (std::exception& e) {
38486       {
38487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38488       };
38489     } catch (Dali::DaliException e) {
38490       {
38491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38492       };
38493     } catch (...) {
38494       {
38495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38496       };
38497     }
38498   }
38499
38500   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38501   return jresult;
38502 }
38503
38504
38505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38506   void * jresult ;
38507   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38508   Dali::RenderTaskList result;
38509
38510   arg1 = (Dali::Stage *)jarg1;
38511   {
38512     try {
38513       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38514     } catch (std::out_of_range& e) {
38515       {
38516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38517       };
38518     } catch (std::exception& e) {
38519       {
38520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38521       };
38522     } catch (Dali::DaliException e) {
38523       {
38524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38525       };
38526     } catch (...) {
38527       {
38528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38529       };
38530     }
38531   }
38532
38533   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38534   return jresult;
38535 }
38536
38537
38538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38539   unsigned int jresult ;
38540   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38541   unsigned int result;
38542
38543   arg1 = (Dali::Stage *)jarg1;
38544   {
38545     try {
38546       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38547     } catch (std::out_of_range& e) {
38548       {
38549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38550       };
38551     } catch (std::exception& e) {
38552       {
38553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38554       };
38555     } catch (Dali::DaliException e) {
38556       {
38557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38558       };
38559     } catch (...) {
38560       {
38561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38562       };
38563     }
38564   }
38565
38566   jresult = result;
38567   return jresult;
38568 }
38569
38570
38571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38572   void * jresult ;
38573   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38574   unsigned int arg2 ;
38575   Dali::Layer result;
38576
38577   arg1 = (Dali::Stage *)jarg1;
38578   arg2 = (unsigned int)jarg2;
38579   {
38580     try {
38581       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38582     } catch (std::out_of_range& e) {
38583       {
38584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38585       };
38586     } catch (std::exception& e) {
38587       {
38588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38589       };
38590     } catch (Dali::DaliException e) {
38591       {
38592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38593       };
38594     } catch (...) {
38595       {
38596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38597       };
38598     }
38599   }
38600
38601   jresult = new Dali::Layer((const Dali::Layer &)result);
38602   return jresult;
38603 }
38604
38605
38606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38607   void * jresult ;
38608   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38609   Dali::Layer result;
38610
38611   arg1 = (Dali::Stage *)jarg1;
38612   {
38613     try {
38614       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38615     } catch (std::out_of_range& e) {
38616       {
38617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38618       };
38619     } catch (std::exception& e) {
38620       {
38621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38622       };
38623     } catch (Dali::DaliException e) {
38624       {
38625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38626       };
38627     } catch (...) {
38628       {
38629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38630       };
38631     }
38632   }
38633
38634   jresult = new Dali::Layer((const Dali::Layer &)result);
38635   return jresult;
38636 }
38637
38638
38639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38640   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38641   Dali::Vector4 arg2 ;
38642   Dali::Vector4 *argp2 ;
38643
38644   arg1 = (Dali::Stage *)jarg1;
38645   argp2 = (Dali::Vector4 *)jarg2;
38646   if (!argp2) {
38647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38648     return ;
38649   }
38650   arg2 = *argp2;
38651   {
38652     try {
38653       (arg1)->SetBackgroundColor(arg2);
38654     } catch (std::out_of_range& e) {
38655       {
38656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38657       };
38658     } catch (std::exception& e) {
38659       {
38660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38661       };
38662     } catch (Dali::DaliException e) {
38663       {
38664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38665       };
38666     } catch (...) {
38667       {
38668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38669       };
38670     }
38671   }
38672
38673 }
38674
38675
38676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38677   void * jresult ;
38678   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38679   Dali::Vector4 result;
38680
38681   arg1 = (Dali::Stage *)jarg1;
38682   {
38683     try {
38684       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38685     } catch (std::out_of_range& e) {
38686       {
38687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38688       };
38689     } catch (std::exception& e) {
38690       {
38691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38692       };
38693     } catch (Dali::DaliException e) {
38694       {
38695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38696       };
38697     } catch (...) {
38698       {
38699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38700       };
38701     }
38702   }
38703
38704   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38705   return jresult;
38706 }
38707
38708
38709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38710   void * jresult ;
38711   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38712   Dali::Vector2 result;
38713
38714   arg1 = (Dali::Stage *)jarg1;
38715   {
38716     try {
38717       result = ((Dali::Stage const *)arg1)->GetDpi();
38718     } catch (std::out_of_range& e) {
38719       {
38720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38721       };
38722     } catch (std::exception& e) {
38723       {
38724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38725       };
38726     } catch (Dali::DaliException e) {
38727       {
38728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38729       };
38730     } catch (...) {
38731       {
38732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38733       };
38734     }
38735   }
38736
38737   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38738   return jresult;
38739 }
38740
38741
38742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38743   void * jresult ;
38744   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38745   Dali::ObjectRegistry result;
38746
38747   arg1 = (Dali::Stage *)jarg1;
38748   {
38749     try {
38750       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38751     } catch (std::out_of_range& e) {
38752       {
38753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38754       };
38755     } catch (std::exception& e) {
38756       {
38757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38758       };
38759     } catch (Dali::DaliException e) {
38760       {
38761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38762       };
38763     } catch (...) {
38764       {
38765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38766       };
38767     }
38768   }
38769
38770   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38771   return jresult;
38772 }
38773
38774
38775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38776   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38777   float arg2 ;
38778
38779   arg1 = (Dali::Stage *)jarg1;
38780   arg2 = (float)jarg2;
38781   {
38782     try {
38783       (arg1)->KeepRendering(arg2);
38784     } catch (std::out_of_range& e) {
38785       {
38786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38787       };
38788     } catch (std::exception& e) {
38789       {
38790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38791       };
38792     } catch (Dali::DaliException e) {
38793       {
38794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38795       };
38796     } catch (...) {
38797       {
38798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38799       };
38800     }
38801   }
38802
38803 }
38804
38805
38806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38807   void * jresult ;
38808   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38809   Dali::Stage::KeyEventSignalType *result = 0 ;
38810
38811   arg1 = (Dali::Stage *)jarg1;
38812   {
38813     try {
38814       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38815     } catch (std::out_of_range& e) {
38816       {
38817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38818       };
38819     } catch (std::exception& e) {
38820       {
38821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38822       };
38823     } catch (Dali::DaliException e) {
38824       {
38825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38826       };
38827     } catch (...) {
38828       {
38829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38830       };
38831     }
38832   }
38833
38834   jresult = (void *)result;
38835   return jresult;
38836 }
38837
38838
38839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38840   void * jresult ;
38841   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38842   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38843
38844   arg1 = (Dali::Stage *)jarg1;
38845   {
38846     try {
38847       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38848     } catch (std::out_of_range& e) {
38849       {
38850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38851       };
38852     } catch (std::exception& e) {
38853       {
38854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38855       };
38856     } catch (Dali::DaliException e) {
38857       {
38858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38859       };
38860     } catch (...) {
38861       {
38862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38863       };
38864     }
38865   }
38866
38867   jresult = (void *)result;
38868   return jresult;
38869 }
38870
38871
38872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38873   void * jresult ;
38874   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38875   Dali::Stage::TouchSignalType *result = 0 ;
38876
38877   arg1 = (Dali::Stage *)jarg1;
38878   {
38879     try {
38880       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38881     } catch (std::out_of_range& e) {
38882       {
38883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38884       };
38885     } catch (std::exception& e) {
38886       {
38887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38888       };
38889     } catch (Dali::DaliException e) {
38890       {
38891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38892       };
38893     } catch (...) {
38894       {
38895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38896       };
38897     }
38898   }
38899
38900   jresult = (void *)result;
38901   return jresult;
38902 }
38903
38904
38905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38906   void * jresult ;
38907   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38908   Dali::Stage::WheelEventSignalType *result = 0 ;
38909
38910   arg1 = (Dali::Stage *)jarg1;
38911   {
38912     try {
38913       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38914     } catch (std::out_of_range& e) {
38915       {
38916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38917       };
38918     } catch (std::exception& e) {
38919       {
38920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38921       };
38922     } catch (Dali::DaliException e) {
38923       {
38924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38925       };
38926     } catch (...) {
38927       {
38928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38929       };
38930     }
38931   }
38932
38933   jresult = (void *)result;
38934   return jresult;
38935 }
38936
38937
38938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38939   void * jresult ;
38940   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38941   Dali::Stage::ContextStatusSignal *result = 0 ;
38942
38943   arg1 = (Dali::Stage *)jarg1;
38944   {
38945     try {
38946       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38947     } catch (std::out_of_range& e) {
38948       {
38949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38950       };
38951     } catch (std::exception& e) {
38952       {
38953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38954       };
38955     } catch (Dali::DaliException e) {
38956       {
38957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38958       };
38959     } catch (...) {
38960       {
38961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38962       };
38963     }
38964   }
38965
38966   jresult = (void *)result;
38967   return jresult;
38968 }
38969
38970
38971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38972   void * jresult ;
38973   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38974   Dali::Stage::ContextStatusSignal *result = 0 ;
38975
38976   arg1 = (Dali::Stage *)jarg1;
38977   {
38978     try {
38979       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38980     } catch (std::out_of_range& e) {
38981       {
38982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (std::exception& e) {
38985       {
38986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38987       };
38988     } catch (Dali::DaliException e) {
38989       {
38990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38991       };
38992     } catch (...) {
38993       {
38994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38995       };
38996     }
38997   }
38998
38999   jresult = (void *)result;
39000   return jresult;
39001 }
39002
39003
39004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39005   void * jresult ;
39006   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39007   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39008
39009   arg1 = (Dali::Stage *)jarg1;
39010   {
39011     try {
39012       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39013     } catch (std::out_of_range& e) {
39014       {
39015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39016       };
39017     } catch (std::exception& e) {
39018       {
39019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39020       };
39021     } catch (Dali::DaliException e) {
39022       {
39023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39024       };
39025     } catch (...) {
39026       {
39027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39028       };
39029     }
39030   }
39031
39032   jresult = (void *)result;
39033   return jresult;
39034 }
39035
39036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39037   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39038   Dali::DevelStage::Rendering arg2 ;
39039
39040   arg1 = (Dali::Stage *)jarg1;
39041   arg2 = (Dali::DevelStage::Rendering)jarg2;
39042   {
39043     try {
39044       DevelStage::SetRenderingBehavior(*arg1,arg2);
39045     } catch (std::out_of_range& e) {
39046       {
39047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39048       };
39049     } catch (std::exception& e) {
39050       {
39051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39052       };
39053     } catch (Dali::DaliException e) {
39054       {
39055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39056       };
39057     } catch (...) {
39058       {
39059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39060       };
39061     }
39062   }
39063
39064 }
39065
39066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39067
39068   int jresult ;
39069   int result ;
39070   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39071
39072   arg1 = (Dali::Stage *)jarg1;
39073   {
39074     try {
39075       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39076     } catch (std::out_of_range& e) {
39077       {
39078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39079       };
39080     } catch (std::exception& e) {
39081       {
39082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39083       };
39084     } catch (Dali::DaliException e) {
39085       {
39086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39087       };
39088     } catch (...) {
39089       {
39090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39091       };
39092     }
39093   }
39094
39095   jresult = result;
39096   return jresult;
39097 }
39098
39099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39100   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39101
39102   arg1 = (Dali::RelayoutContainer *)jarg1;
39103   {
39104     try {
39105       delete arg1;
39106     } catch (std::out_of_range& e) {
39107       {
39108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39109       };
39110     } catch (std::exception& e) {
39111       {
39112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39113       };
39114     } catch (Dali::DaliException e) {
39115       {
39116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39117       };
39118     } catch (...) {
39119       {
39120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39121       };
39122     }
39123   }
39124
39125 }
39126
39127
39128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39129   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39130   Dali::Actor *arg2 = 0 ;
39131   Dali::Vector2 *arg3 = 0 ;
39132
39133   arg1 = (Dali::RelayoutContainer *)jarg1;
39134   arg2 = (Dali::Actor *)jarg2;
39135   if (!arg2) {
39136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39137     return ;
39138   }
39139   arg3 = (Dali::Vector2 *)jarg3;
39140   if (!arg3) {
39141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39142     return ;
39143   }
39144   {
39145     try {
39146       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39147     } catch (std::out_of_range& e) {
39148       {
39149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39150       };
39151     } catch (std::exception& e) {
39152       {
39153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39154       };
39155     } catch (Dali::DaliException e) {
39156       {
39157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39158       };
39159     } catch (...) {
39160       {
39161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39162       };
39163     }
39164   }
39165
39166 }
39167
39168
39169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39170   void * jresult ;
39171   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39172   Dali::CustomActor result;
39173
39174   arg1 = (Dali::CustomActorImpl *)jarg1;
39175   {
39176     try {
39177       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39178     } catch (std::out_of_range& e) {
39179       {
39180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39181       };
39182     } catch (std::exception& e) {
39183       {
39184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39185       };
39186     } catch (Dali::DaliException e) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39189       };
39190     } catch (...) {
39191       {
39192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39193       };
39194     }
39195   }
39196
39197   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39198   return jresult;
39199 }
39200
39201
39202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39203   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39204   int arg2 ;
39205
39206   arg1 = (Dali::CustomActorImpl *)jarg1;
39207   arg2 = (int)jarg2;
39208   {
39209     try {
39210       (arg1)->OnStageConnection(arg2);
39211     } catch (std::out_of_range& e) {
39212       {
39213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39214       };
39215     } catch (std::exception& e) {
39216       {
39217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39218       };
39219     } catch (Dali::DaliException e) {
39220       {
39221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39222       };
39223     } catch (...) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39226       };
39227     }
39228   }
39229
39230 }
39231
39232
39233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39234   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39235
39236   arg1 = (Dali::CustomActorImpl *)jarg1;
39237   {
39238     try {
39239       (arg1)->OnStageDisconnection();
39240     } catch (std::out_of_range& e) {
39241       {
39242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39243       };
39244     } catch (std::exception& e) {
39245       {
39246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39247       };
39248     } catch (Dali::DaliException e) {
39249       {
39250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39251       };
39252     } catch (...) {
39253       {
39254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39255       };
39256     }
39257   }
39258
39259 }
39260
39261
39262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39263   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39264   Dali::Actor *arg2 = 0 ;
39265
39266   arg1 = (Dali::CustomActorImpl *)jarg1;
39267   arg2 = (Dali::Actor *)jarg2;
39268   if (!arg2) {
39269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39270     return ;
39271   }
39272   {
39273     try {
39274       (arg1)->OnChildAdd(*arg2);
39275     } catch (std::out_of_range& e) {
39276       {
39277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39278       };
39279     } catch (std::exception& e) {
39280       {
39281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39282       };
39283     } catch (Dali::DaliException e) {
39284       {
39285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39286       };
39287     } catch (...) {
39288       {
39289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39290       };
39291     }
39292   }
39293
39294 }
39295
39296
39297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39298   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39299   Dali::Actor *arg2 = 0 ;
39300
39301   arg1 = (Dali::CustomActorImpl *)jarg1;
39302   arg2 = (Dali::Actor *)jarg2;
39303   if (!arg2) {
39304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39305     return ;
39306   }
39307   {
39308     try {
39309       (arg1)->OnChildRemove(*arg2);
39310     } catch (std::out_of_range& e) {
39311       {
39312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39313       };
39314     } catch (std::exception& e) {
39315       {
39316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39317       };
39318     } catch (Dali::DaliException e) {
39319       {
39320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39321       };
39322     } catch (...) {
39323       {
39324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39325       };
39326     }
39327   }
39328
39329 }
39330
39331
39332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39333   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39334   Dali::Property::Index arg2 ;
39335   Dali::Property::Value arg3 ;
39336   Dali::Property::Value *argp3 ;
39337
39338   arg1 = (Dali::CustomActorImpl *)jarg1;
39339   arg2 = (Dali::Property::Index)jarg2;
39340   argp3 = (Dali::Property::Value *)jarg3;
39341   if (!argp3) {
39342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39343     return ;
39344   }
39345   arg3 = *argp3;
39346   {
39347     try {
39348       (arg1)->OnPropertySet(arg2,arg3);
39349     } catch (std::out_of_range& e) {
39350       {
39351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (std::exception& e) {
39354       {
39355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39356       };
39357     } catch (Dali::DaliException e) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39360       };
39361     } catch (...) {
39362       {
39363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39364       };
39365     }
39366   }
39367
39368 }
39369
39370
39371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39372   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39373   Dali::Vector3 *arg2 = 0 ;
39374
39375   arg1 = (Dali::CustomActorImpl *)jarg1;
39376   arg2 = (Dali::Vector3 *)jarg2;
39377   if (!arg2) {
39378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39379     return ;
39380   }
39381   {
39382     try {
39383       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39384     } catch (std::out_of_range& e) {
39385       {
39386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39387       };
39388     } catch (std::exception& e) {
39389       {
39390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39391       };
39392     } catch (Dali::DaliException e) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39395       };
39396     } catch (...) {
39397       {
39398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39399       };
39400     }
39401   }
39402
39403 }
39404
39405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39406   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39407   Dali::Animation *arg2 = 0 ;
39408   Dali::Vector3 *arg3 = 0 ;
39409
39410   arg1 = (Dali::CustomActorImpl *)jarg1;
39411   arg2 = (Dali::Animation *)jarg2;
39412   if (!arg2) {
39413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39414     return ;
39415   }
39416   arg3 = (Dali::Vector3 *)jarg3;
39417   if (!arg3) {
39418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39419     return ;
39420   }
39421   {
39422     try {
39423       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39424     } catch (std::out_of_range& e) {
39425       {
39426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39427       };
39428     } catch (std::exception& e) {
39429       {
39430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39431       };
39432     } catch (Dali::DaliException e) {
39433       {
39434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39435       };
39436     } catch (...) {
39437       {
39438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39439       };
39440     }
39441   }
39442
39443 }
39444
39445
39446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39447   unsigned int jresult ;
39448   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39449   Dali::TouchEvent *arg2 = 0 ;
39450   bool result;
39451
39452   arg1 = (Dali::CustomActorImpl *)jarg1;
39453   arg2 = (Dali::TouchEvent *)jarg2;
39454   if (!arg2) {
39455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39456     return 0;
39457   }
39458   {
39459     try {
39460       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39461     } catch (std::out_of_range& e) {
39462       {
39463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39464       };
39465     } catch (std::exception& e) {
39466       {
39467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39468       };
39469     } catch (Dali::DaliException e) {
39470       {
39471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39472       };
39473     } catch (...) {
39474       {
39475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39476       };
39477     }
39478   }
39479
39480   jresult = result;
39481   return jresult;
39482 }
39483
39484
39485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39486   unsigned int jresult ;
39487   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39488   Dali::HoverEvent *arg2 = 0 ;
39489   bool result;
39490
39491   arg1 = (Dali::CustomActorImpl *)jarg1;
39492   arg2 = (Dali::HoverEvent *)jarg2;
39493   if (!arg2) {
39494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39495     return 0;
39496   }
39497   {
39498     try {
39499       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39500     } catch (std::out_of_range& e) {
39501       {
39502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39503       };
39504     } catch (std::exception& e) {
39505       {
39506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39507       };
39508     } catch (Dali::DaliException e) {
39509       {
39510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39511       };
39512     } catch (...) {
39513       {
39514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39515       };
39516     }
39517   }
39518
39519   jresult = result;
39520   return jresult;
39521 }
39522
39523
39524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39525   unsigned int jresult ;
39526   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39527   Dali::KeyEvent *arg2 = 0 ;
39528   bool result;
39529
39530   arg1 = (Dali::CustomActorImpl *)jarg1;
39531   arg2 = (Dali::KeyEvent *)jarg2;
39532   if (!arg2) {
39533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39534     return 0;
39535   }
39536   {
39537     try {
39538       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39539     } catch (std::out_of_range& e) {
39540       {
39541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39542       };
39543     } catch (std::exception& e) {
39544       {
39545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39546       };
39547     } catch (Dali::DaliException e) {
39548       {
39549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39550       };
39551     } catch (...) {
39552       {
39553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39554       };
39555     }
39556   }
39557
39558   jresult = result;
39559   return jresult;
39560 }
39561
39562
39563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39564   unsigned int jresult ;
39565   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39566   Dali::WheelEvent *arg2 = 0 ;
39567   bool result;
39568
39569   arg1 = (Dali::CustomActorImpl *)jarg1;
39570   arg2 = (Dali::WheelEvent *)jarg2;
39571   if (!arg2) {
39572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39573     return 0;
39574   }
39575   {
39576     try {
39577       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39578     } catch (std::out_of_range& e) {
39579       {
39580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39581       };
39582     } catch (std::exception& e) {
39583       {
39584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (Dali::DaliException e) {
39587       {
39588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39589       };
39590     } catch (...) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39593       };
39594     }
39595   }
39596
39597   jresult = result;
39598   return jresult;
39599 }
39600
39601
39602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39603   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39604   Dali::Vector2 *arg2 = 0 ;
39605   Dali::RelayoutContainer *arg3 = 0 ;
39606
39607   arg1 = (Dali::CustomActorImpl *)jarg1;
39608   arg2 = (Dali::Vector2 *)jarg2;
39609   if (!arg2) {
39610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39611     return ;
39612   }
39613   arg3 = (Dali::RelayoutContainer *)jarg3;
39614   if (!arg3) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39616     return ;
39617   }
39618   {
39619     try {
39620       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39628       };
39629     } catch (Dali::DaliException e) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39632       };
39633     } catch (...) {
39634       {
39635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39636       };
39637     }
39638   }
39639
39640 }
39641
39642
39643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39644   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39645   Dali::ResizePolicy::Type arg2 ;
39646   Dali::Dimension::Type arg3 ;
39647
39648   arg1 = (Dali::CustomActorImpl *)jarg1;
39649   arg2 = (Dali::ResizePolicy::Type)jarg2;
39650   arg3 = (Dali::Dimension::Type)jarg3;
39651   {
39652     try {
39653       (arg1)->OnSetResizePolicy(arg2,arg3);
39654     } catch (std::out_of_range& e) {
39655       {
39656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39657       };
39658     } catch (std::exception& e) {
39659       {
39660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39661       };
39662     } catch (Dali::DaliException e) {
39663       {
39664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39665       };
39666     } catch (...) {
39667       {
39668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39669       };
39670     }
39671   }
39672
39673 }
39674
39675
39676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39677   void * jresult ;
39678   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39679   Dali::Vector3 result;
39680
39681   arg1 = (Dali::CustomActorImpl *)jarg1;
39682   {
39683     try {
39684       result = (arg1)->GetNaturalSize();
39685     } catch (std::out_of_range& e) {
39686       {
39687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39688       };
39689     } catch (std::exception& e) {
39690       {
39691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39692       };
39693     } catch (Dali::DaliException e) {
39694       {
39695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39696       };
39697     } catch (...) {
39698       {
39699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39700       };
39701     }
39702   }
39703
39704   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39705   return jresult;
39706 }
39707
39708
39709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39710   float jresult ;
39711   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39712   Dali::Actor *arg2 = 0 ;
39713   Dali::Dimension::Type arg3 ;
39714   float result;
39715
39716   arg1 = (Dali::CustomActorImpl *)jarg1;
39717   arg2 = (Dali::Actor *)jarg2;
39718   if (!arg2) {
39719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39720     return 0;
39721   }
39722   arg3 = (Dali::Dimension::Type)jarg3;
39723   {
39724     try {
39725       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39726     } catch (std::out_of_range& e) {
39727       {
39728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39729       };
39730     } catch (std::exception& e) {
39731       {
39732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39733       };
39734     } catch (Dali::DaliException e) {
39735       {
39736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39737       };
39738     } catch (...) {
39739       {
39740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39741       };
39742     }
39743   }
39744
39745   jresult = result;
39746   return jresult;
39747 }
39748
39749
39750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39751   float jresult ;
39752   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39753   float arg2 ;
39754   float result;
39755
39756   arg1 = (Dali::CustomActorImpl *)jarg1;
39757   arg2 = (float)jarg2;
39758   {
39759     try {
39760       result = (float)(arg1)->GetHeightForWidth(arg2);
39761     } catch (std::out_of_range& e) {
39762       {
39763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39764       };
39765     } catch (std::exception& e) {
39766       {
39767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39768       };
39769     } catch (Dali::DaliException e) {
39770       {
39771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39772       };
39773     } catch (...) {
39774       {
39775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39776       };
39777     }
39778   }
39779
39780   jresult = result;
39781   return jresult;
39782 }
39783
39784
39785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39786   float jresult ;
39787   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39788   float arg2 ;
39789   float result;
39790
39791   arg1 = (Dali::CustomActorImpl *)jarg1;
39792   arg2 = (float)jarg2;
39793   {
39794     try {
39795       result = (float)(arg1)->GetWidthForHeight(arg2);
39796     } catch (std::out_of_range& e) {
39797       {
39798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39799       };
39800     } catch (std::exception& e) {
39801       {
39802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39803       };
39804     } catch (Dali::DaliException e) {
39805       {
39806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39807       };
39808     } catch (...) {
39809       {
39810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39811       };
39812     }
39813   }
39814
39815   jresult = result;
39816   return jresult;
39817 }
39818
39819
39820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39821   unsigned int jresult ;
39822   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39823   Dali::Dimension::Type arg2 ;
39824   bool result;
39825
39826   arg1 = (Dali::CustomActorImpl *)jarg1;
39827   arg2 = (Dali::Dimension::Type)jarg2;
39828   {
39829     try {
39830       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39831     } catch (std::out_of_range& e) {
39832       {
39833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39834       };
39835     } catch (std::exception& e) {
39836       {
39837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39838       };
39839     } catch (Dali::DaliException e) {
39840       {
39841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39842       };
39843     } catch (...) {
39844       {
39845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39846       };
39847     }
39848   }
39849
39850   jresult = result;
39851   return jresult;
39852 }
39853
39854
39855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39856   unsigned int jresult ;
39857   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39858   bool result;
39859
39860   arg1 = (Dali::CustomActorImpl *)jarg1;
39861   {
39862     try {
39863       result = (bool)(arg1)->RelayoutDependentOnChildren();
39864     } catch (std::out_of_range& e) {
39865       {
39866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39867       };
39868     } catch (std::exception& e) {
39869       {
39870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39871       };
39872     } catch (Dali::DaliException e) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39875       };
39876     } catch (...) {
39877       {
39878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39879       };
39880     }
39881   }
39882
39883   jresult = result;
39884   return jresult;
39885 }
39886
39887
39888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39889   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39890   Dali::Dimension::Type arg2 ;
39891
39892   arg1 = (Dali::CustomActorImpl *)jarg1;
39893   arg2 = (Dali::Dimension::Type)jarg2;
39894   {
39895     try {
39896       (arg1)->OnCalculateRelayoutSize(arg2);
39897     } catch (std::out_of_range& e) {
39898       {
39899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (std::exception& e) {
39902       {
39903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39904       };
39905     } catch (Dali::DaliException e) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39908       };
39909     } catch (...) {
39910       {
39911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39912       };
39913     }
39914   }
39915
39916 }
39917
39918
39919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39920   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39921   float arg2 ;
39922   Dali::Dimension::Type arg3 ;
39923
39924   arg1 = (Dali::CustomActorImpl *)jarg1;
39925   arg2 = (float)jarg2;
39926   arg3 = (Dali::Dimension::Type)jarg3;
39927   {
39928     try {
39929       (arg1)->OnLayoutNegotiated(arg2,arg3);
39930     } catch (std::out_of_range& e) {
39931       {
39932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39933       };
39934     } catch (std::exception& e) {
39935       {
39936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39937       };
39938     } catch (Dali::DaliException e) {
39939       {
39940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39941       };
39942     } catch (...) {
39943       {
39944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39945       };
39946     }
39947   }
39948
39949 }
39950
39951
39952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39953   unsigned int jresult ;
39954   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39955   bool result;
39956
39957   arg1 = (Dali::CustomActorImpl *)jarg1;
39958   {
39959     try {
39960       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39961     } catch (std::out_of_range& e) {
39962       {
39963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39964       };
39965     } catch (std::exception& e) {
39966       {
39967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39968       };
39969     } catch (Dali::DaliException e) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39972       };
39973     } catch (...) {
39974       {
39975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39976       };
39977     }
39978   }
39979
39980   jresult = result;
39981   return jresult;
39982 }
39983
39984
39985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39986   unsigned int jresult ;
39987   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39988   bool result;
39989
39990   arg1 = (Dali::CustomActorImpl *)jarg1;
39991   {
39992     try {
39993       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39994     } catch (std::out_of_range& e) {
39995       {
39996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39997       };
39998     } catch (std::exception& e) {
39999       {
40000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40001       };
40002     } catch (Dali::DaliException e) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40005       };
40006     } catch (...) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40009       };
40010     }
40011   }
40012
40013   jresult = result;
40014   return jresult;
40015 }
40016
40017
40018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40019   unsigned int jresult ;
40020   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40021   bool result;
40022
40023   arg1 = (Dali::CustomActorImpl *)jarg1;
40024   {
40025     try {
40026       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40027     } catch (std::out_of_range& e) {
40028       {
40029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (std::exception& e) {
40032       {
40033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40034       };
40035     } catch (Dali::DaliException e) {
40036       {
40037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40038       };
40039     } catch (...) {
40040       {
40041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40042       };
40043     }
40044   }
40045
40046   jresult = result;
40047   return jresult;
40048 }
40049
40050
40051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40052   unsigned int jresult ;
40053   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40054   bool result;
40055
40056   arg1 = (Dali::CustomActorImpl *)jarg1;
40057   {
40058     try {
40059       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40060     } catch (std::out_of_range& e) {
40061       {
40062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40063       };
40064     } catch (std::exception& e) {
40065       {
40066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40067       };
40068     } catch (Dali::DaliException e) {
40069       {
40070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40071       };
40072     } catch (...) {
40073       {
40074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40075       };
40076     }
40077   }
40078
40079   jresult = result;
40080   return jresult;
40081 }
40082
40083
40084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40085   void * jresult ;
40086   Dali::CustomActor *result = 0 ;
40087
40088   {
40089     try {
40090       result = (Dali::CustomActor *)new Dali::CustomActor();
40091     } catch (std::out_of_range& e) {
40092       {
40093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40094       };
40095     } catch (std::exception& e) {
40096       {
40097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40098       };
40099     } catch (Dali::DaliException e) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40102       };
40103     } catch (...) {
40104       {
40105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40106       };
40107     }
40108   }
40109
40110   jresult = (void *)result;
40111   return jresult;
40112 }
40113
40114
40115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40116   void * jresult ;
40117   Dali::BaseHandle arg1 ;
40118   Dali::BaseHandle *argp1 ;
40119   Dali::CustomActor result;
40120
40121   argp1 = (Dali::BaseHandle *)jarg1;
40122   if (!argp1) {
40123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40124     return 0;
40125   }
40126   arg1 = *argp1;
40127   {
40128     try {
40129       result = Dali::CustomActor::DownCast(arg1);
40130     } catch (std::out_of_range& e) {
40131       {
40132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40133       };
40134     } catch (std::exception& e) {
40135       {
40136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40137       };
40138     } catch (Dali::DaliException e) {
40139       {
40140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40141       };
40142     } catch (...) {
40143       {
40144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40145       };
40146     }
40147   }
40148
40149   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40150   return jresult;
40151 }
40152
40153
40154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40155   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40156
40157   arg1 = (Dali::CustomActor *)jarg1;
40158   {
40159     try {
40160       delete arg1;
40161     } catch (std::out_of_range& e) {
40162       {
40163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40164       };
40165     } catch (std::exception& e) {
40166       {
40167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40168       };
40169     } catch (Dali::DaliException e) {
40170       {
40171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40172       };
40173     } catch (...) {
40174       {
40175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40176       };
40177     }
40178   }
40179
40180 }
40181
40182
40183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40184   void * jresult ;
40185   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40186   Dali::CustomActorImpl *result = 0 ;
40187
40188   arg1 = (Dali::CustomActor *)jarg1;
40189   {
40190     try {
40191       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40192     } catch (std::out_of_range& e) {
40193       {
40194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40195       };
40196     } catch (std::exception& e) {
40197       {
40198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40199       };
40200     } catch (Dali::DaliException e) {
40201       {
40202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40203       };
40204     } catch (...) {
40205       {
40206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40207       };
40208     }
40209   }
40210
40211   jresult = (void *)result;
40212   return jresult;
40213 }
40214
40215
40216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40217   void * jresult ;
40218   Dali::CustomActorImpl *arg1 = 0 ;
40219   Dali::CustomActor *result = 0 ;
40220
40221   arg1 = (Dali::CustomActorImpl *)jarg1;
40222   if (!arg1) {
40223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40224     return 0;
40225   }
40226   {
40227     try {
40228       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40229     } catch (std::out_of_range& e) {
40230       {
40231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40232       };
40233     } catch (std::exception& e) {
40234       {
40235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40236       };
40237     } catch (Dali::DaliException e) {
40238       {
40239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40240       };
40241     } catch (...) {
40242       {
40243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40244       };
40245     }
40246   }
40247
40248   jresult = (void *)result;
40249   return jresult;
40250 }
40251
40252
40253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40254   void * jresult ;
40255   Dali::CustomActor *arg1 = 0 ;
40256   Dali::CustomActor *result = 0 ;
40257
40258   arg1 = (Dali::CustomActor *)jarg1;
40259   if (!arg1) {
40260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40261     return 0;
40262   }
40263   {
40264     try {
40265       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40266     } catch (std::out_of_range& e) {
40267       {
40268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40269       };
40270     } catch (std::exception& e) {
40271       {
40272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40273       };
40274     } catch (Dali::DaliException e) {
40275       {
40276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40277       };
40278     } catch (...) {
40279       {
40280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40281       };
40282     }
40283   }
40284
40285   jresult = (void *)result;
40286   return jresult;
40287 }
40288
40289
40290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40291   void * jresult ;
40292   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40293   Dali::CustomActor *arg2 = 0 ;
40294   Dali::CustomActor *result = 0 ;
40295
40296   arg1 = (Dali::CustomActor *)jarg1;
40297   arg2 = (Dali::CustomActor *)jarg2;
40298   if (!arg2) {
40299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40300     return 0;
40301   }
40302   {
40303     try {
40304       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40305     } catch (std::out_of_range& e) {
40306       {
40307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40308       };
40309     } catch (std::exception& e) {
40310       {
40311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40312       };
40313     } catch (Dali::DaliException e) {
40314       {
40315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40316       };
40317     } catch (...) {
40318       {
40319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40320       };
40321     }
40322   }
40323
40324   jresult = (void *)result;
40325   return jresult;
40326 }
40327
40328
40329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40330   int jresult ;
40331   int result;
40332
40333   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40334   jresult = (int)result;
40335   return jresult;
40336 }
40337
40338
40339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40340   int jresult ;
40341   int result;
40342
40343   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40344   jresult = (int)result;
40345   return jresult;
40346 }
40347
40348
40349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40350   int jresult ;
40351   int result;
40352
40353   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40354   jresult = (int)result;
40355   return jresult;
40356 }
40357
40358
40359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40360   int jresult ;
40361   int result;
40362
40363   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40364   jresult = (int)result;
40365   return jresult;
40366 }
40367
40368
40369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40370   int jresult ;
40371   int result;
40372
40373   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40374   jresult = (int)result;
40375   return jresult;
40376 }
40377
40378
40379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40380   int jresult ;
40381   int result;
40382
40383   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40384   jresult = (int)result;
40385   return jresult;
40386 }
40387
40388
40389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40390   int jresult ;
40391   int result;
40392
40393   result = (int)Dali::PanGestureDetector::Property::PANNING;
40394   jresult = (int)result;
40395   return jresult;
40396 }
40397
40398
40399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40400   void * jresult ;
40401   Dali::PanGestureDetector::Property *result = 0 ;
40402
40403   {
40404     try {
40405       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40406     } catch (std::out_of_range& e) {
40407       {
40408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40409       };
40410     } catch (std::exception& e) {
40411       {
40412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40413       };
40414     } catch (Dali::DaliException e) {
40415       {
40416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40417       };
40418     } catch (...) {
40419       {
40420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40421       };
40422     }
40423   }
40424
40425   jresult = (void *)result;
40426   return jresult;
40427 }
40428
40429
40430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40431   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40432
40433   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40434   {
40435     try {
40436       delete arg1;
40437     } catch (std::out_of_range& e) {
40438       {
40439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40440       };
40441     } catch (std::exception& e) {
40442       {
40443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40444       };
40445     } catch (Dali::DaliException e) {
40446       {
40447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40448       };
40449     } catch (...) {
40450       {
40451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40452       };
40453     }
40454   }
40455
40456 }
40457
40458
40459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40460   void * jresult ;
40461   Dali::Radian *result = 0 ;
40462
40463   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40464   jresult = (void *)result;
40465   return jresult;
40466 }
40467
40468
40469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40470   void * jresult ;
40471   Dali::Radian *result = 0 ;
40472
40473   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40474   jresult = (void *)result;
40475   return jresult;
40476 }
40477
40478
40479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40480   void * jresult ;
40481   Dali::Radian *result = 0 ;
40482
40483   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40484   jresult = (void *)result;
40485   return jresult;
40486 }
40487
40488
40489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40490   void * jresult ;
40491   Dali::Radian *result = 0 ;
40492
40493   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40494   jresult = (void *)result;
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40500   void * jresult ;
40501   Dali::Radian *result = 0 ;
40502
40503   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40504   jresult = (void *)result;
40505   return jresult;
40506 }
40507
40508
40509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40510   void * jresult ;
40511   Dali::Radian *result = 0 ;
40512
40513   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40514   jresult = (void *)result;
40515   return jresult;
40516 }
40517
40518
40519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40520   void * jresult ;
40521   Dali::Radian *result = 0 ;
40522
40523   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40524   jresult = (void *)result;
40525   return jresult;
40526 }
40527
40528
40529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40530   void * jresult ;
40531   Dali::PanGestureDetector *result = 0 ;
40532
40533   {
40534     try {
40535       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40536     } catch (std::out_of_range& e) {
40537       {
40538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (std::exception& e) {
40541       {
40542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40543       };
40544     } catch (Dali::DaliException e) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40547       };
40548     } catch (...) {
40549       {
40550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40551       };
40552     }
40553   }
40554
40555   jresult = (void *)result;
40556   return jresult;
40557 }
40558
40559
40560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40561   void * jresult ;
40562   Dali::PanGestureDetector result;
40563
40564   {
40565     try {
40566       result = Dali::PanGestureDetector::New();
40567     } catch (std::out_of_range& e) {
40568       {
40569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (std::exception& e) {
40572       {
40573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40574       };
40575     } catch (Dali::DaliException e) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40578       };
40579     } catch (...) {
40580       {
40581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40582       };
40583     }
40584   }
40585
40586   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40587   return jresult;
40588 }
40589
40590
40591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40592   void * jresult ;
40593   Dali::BaseHandle arg1 ;
40594   Dali::BaseHandle *argp1 ;
40595   Dali::PanGestureDetector result;
40596
40597   argp1 = (Dali::BaseHandle *)jarg1;
40598   if (!argp1) {
40599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40600     return 0;
40601   }
40602   arg1 = *argp1;
40603   {
40604     try {
40605       result = Dali::PanGestureDetector::DownCast(arg1);
40606     } catch (std::out_of_range& e) {
40607       {
40608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40609       };
40610     } catch (std::exception& e) {
40611       {
40612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40613       };
40614     } catch (Dali::DaliException e) {
40615       {
40616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40617       };
40618     } catch (...) {
40619       {
40620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40621       };
40622     }
40623   }
40624
40625   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40626   return jresult;
40627 }
40628
40629
40630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40631   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40632
40633   arg1 = (Dali::PanGestureDetector *)jarg1;
40634   {
40635     try {
40636       delete arg1;
40637     } catch (std::out_of_range& e) {
40638       {
40639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40640       };
40641     } catch (std::exception& e) {
40642       {
40643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40644       };
40645     } catch (Dali::DaliException e) {
40646       {
40647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40648       };
40649     } catch (...) {
40650       {
40651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40652       };
40653     }
40654   }
40655
40656 }
40657
40658
40659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40660   void * jresult ;
40661   Dali::PanGestureDetector *arg1 = 0 ;
40662   Dali::PanGestureDetector *result = 0 ;
40663
40664   arg1 = (Dali::PanGestureDetector *)jarg1;
40665   if (!arg1) {
40666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40667     return 0;
40668   }
40669   {
40670     try {
40671       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40672     } catch (std::out_of_range& e) {
40673       {
40674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40675       };
40676     } catch (std::exception& e) {
40677       {
40678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40679       };
40680     } catch (Dali::DaliException e) {
40681       {
40682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40683       };
40684     } catch (...) {
40685       {
40686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40687       };
40688     }
40689   }
40690
40691   jresult = (void *)result;
40692   return jresult;
40693 }
40694
40695
40696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40697   void * jresult ;
40698   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40699   Dali::PanGestureDetector *arg2 = 0 ;
40700   Dali::PanGestureDetector *result = 0 ;
40701
40702   arg1 = (Dali::PanGestureDetector *)jarg1;
40703   arg2 = (Dali::PanGestureDetector *)jarg2;
40704   if (!arg2) {
40705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40706     return 0;
40707   }
40708   {
40709     try {
40710       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40711     } catch (std::out_of_range& e) {
40712       {
40713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40714       };
40715     } catch (std::exception& e) {
40716       {
40717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40718       };
40719     } catch (Dali::DaliException e) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40722       };
40723     } catch (...) {
40724       {
40725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40726       };
40727     }
40728   }
40729
40730   jresult = (void *)result;
40731   return jresult;
40732 }
40733
40734
40735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40736   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40737   unsigned int arg2 ;
40738
40739   arg1 = (Dali::PanGestureDetector *)jarg1;
40740   arg2 = (unsigned int)jarg2;
40741   {
40742     try {
40743       (arg1)->SetMinimumTouchesRequired(arg2);
40744     } catch (std::out_of_range& e) {
40745       {
40746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40747       };
40748     } catch (std::exception& e) {
40749       {
40750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40751       };
40752     } catch (Dali::DaliException e) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40755       };
40756     } catch (...) {
40757       {
40758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40759       };
40760     }
40761   }
40762
40763 }
40764
40765
40766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40767   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40768   unsigned int arg2 ;
40769
40770   arg1 = (Dali::PanGestureDetector *)jarg1;
40771   arg2 = (unsigned int)jarg2;
40772   {
40773     try {
40774       (arg1)->SetMaximumTouchesRequired(arg2);
40775     } catch (std::out_of_range& e) {
40776       {
40777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40778       };
40779     } catch (std::exception& e) {
40780       {
40781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40782       };
40783     } catch (Dali::DaliException e) {
40784       {
40785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40786       };
40787     } catch (...) {
40788       {
40789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40790       };
40791     }
40792   }
40793
40794 }
40795
40796
40797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40798   unsigned int jresult ;
40799   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40800   unsigned int result;
40801
40802   arg1 = (Dali::PanGestureDetector *)jarg1;
40803   {
40804     try {
40805       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40806     } catch (std::out_of_range& e) {
40807       {
40808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40809       };
40810     } catch (std::exception& e) {
40811       {
40812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40813       };
40814     } catch (Dali::DaliException e) {
40815       {
40816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40817       };
40818     } catch (...) {
40819       {
40820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40821       };
40822     }
40823   }
40824
40825   jresult = result;
40826   return jresult;
40827 }
40828
40829
40830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40831   unsigned int jresult ;
40832   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40833   unsigned int result;
40834
40835   arg1 = (Dali::PanGestureDetector *)jarg1;
40836   {
40837     try {
40838       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40839     } catch (std::out_of_range& e) {
40840       {
40841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40842       };
40843     } catch (std::exception& e) {
40844       {
40845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40846       };
40847     } catch (Dali::DaliException e) {
40848       {
40849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40850       };
40851     } catch (...) {
40852       {
40853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40854       };
40855     }
40856   }
40857
40858   jresult = result;
40859   return jresult;
40860 }
40861
40862
40863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40864   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40865   Dali::Radian arg2 ;
40866   Dali::Radian arg3 ;
40867   Dali::Radian *argp2 ;
40868   Dali::Radian *argp3 ;
40869
40870   arg1 = (Dali::PanGestureDetector *)jarg1;
40871   argp2 = (Dali::Radian *)jarg2;
40872   if (!argp2) {
40873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40874     return ;
40875   }
40876   arg2 = *argp2;
40877   argp3 = (Dali::Radian *)jarg3;
40878   if (!argp3) {
40879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40880     return ;
40881   }
40882   arg3 = *argp3;
40883   {
40884     try {
40885       (arg1)->AddAngle(arg2,arg3);
40886     } catch (std::out_of_range& e) {
40887       {
40888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40889       };
40890     } catch (std::exception& e) {
40891       {
40892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40893       };
40894     } catch (Dali::DaliException e) {
40895       {
40896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40897       };
40898     } catch (...) {
40899       {
40900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40901       };
40902     }
40903   }
40904
40905 }
40906
40907
40908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40909   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40910   Dali::Radian arg2 ;
40911   Dali::Radian *argp2 ;
40912
40913   arg1 = (Dali::PanGestureDetector *)jarg1;
40914   argp2 = (Dali::Radian *)jarg2;
40915   if (!argp2) {
40916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40917     return ;
40918   }
40919   arg2 = *argp2;
40920   {
40921     try {
40922       (arg1)->AddAngle(arg2);
40923     } catch (std::out_of_range& e) {
40924       {
40925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40926       };
40927     } catch (std::exception& e) {
40928       {
40929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40930       };
40931     } catch (Dali::DaliException e) {
40932       {
40933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40934       };
40935     } catch (...) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40938       };
40939     }
40940   }
40941
40942 }
40943
40944
40945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40946   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40947   Dali::Radian arg2 ;
40948   Dali::Radian arg3 ;
40949   Dali::Radian *argp2 ;
40950   Dali::Radian *argp3 ;
40951
40952   arg1 = (Dali::PanGestureDetector *)jarg1;
40953   argp2 = (Dali::Radian *)jarg2;
40954   if (!argp2) {
40955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40956     return ;
40957   }
40958   arg2 = *argp2;
40959   argp3 = (Dali::Radian *)jarg3;
40960   if (!argp3) {
40961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40962     return ;
40963   }
40964   arg3 = *argp3;
40965   {
40966     try {
40967       (arg1)->AddDirection(arg2,arg3);
40968     } catch (std::out_of_range& e) {
40969       {
40970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40971       };
40972     } catch (std::exception& e) {
40973       {
40974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40975       };
40976     } catch (Dali::DaliException e) {
40977       {
40978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40979       };
40980     } catch (...) {
40981       {
40982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40983       };
40984     }
40985   }
40986
40987 }
40988
40989
40990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40991   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40992   Dali::Radian arg2 ;
40993   Dali::Radian *argp2 ;
40994
40995   arg1 = (Dali::PanGestureDetector *)jarg1;
40996   argp2 = (Dali::Radian *)jarg2;
40997   if (!argp2) {
40998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40999     return ;
41000   }
41001   arg2 = *argp2;
41002   {
41003     try {
41004       (arg1)->AddDirection(arg2);
41005     } catch (std::out_of_range& e) {
41006       {
41007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41008       };
41009     } catch (std::exception& e) {
41010       {
41011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41012       };
41013     } catch (Dali::DaliException e) {
41014       {
41015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41016       };
41017     } catch (...) {
41018       {
41019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41020       };
41021     }
41022   }
41023
41024 }
41025
41026
41027 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41028   unsigned long jresult ;
41029   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41030   size_t result;
41031
41032   arg1 = (Dali::PanGestureDetector *)jarg1;
41033   {
41034     try {
41035       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41036     } catch (std::out_of_range& e) {
41037       {
41038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41039       };
41040     } catch (std::exception& e) {
41041       {
41042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41043       };
41044     } catch (Dali::DaliException e) {
41045       {
41046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41047       };
41048     } catch (...) {
41049       {
41050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41051       };
41052     }
41053   }
41054
41055   jresult = (unsigned long)result;
41056   return jresult;
41057 }
41058
41059
41060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41061   void * jresult ;
41062   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41063   size_t arg2 ;
41064   Dali::PanGestureDetector::AngleThresholdPair result;
41065
41066   arg1 = (Dali::PanGestureDetector *)jarg1;
41067   arg2 = (size_t)jarg2;
41068   {
41069     try {
41070       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41071     } catch (std::out_of_range& e) {
41072       {
41073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41074       };
41075     } catch (std::exception& e) {
41076       {
41077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41078       };
41079     } catch (Dali::DaliException e) {
41080       {
41081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41082       };
41083     } catch (...) {
41084       {
41085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41086       };
41087     }
41088   }
41089
41090   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41091   return jresult;
41092 }
41093
41094
41095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41096   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41097
41098   arg1 = (Dali::PanGestureDetector *)jarg1;
41099   {
41100     try {
41101       (arg1)->ClearAngles();
41102     } catch (std::out_of_range& e) {
41103       {
41104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41105       };
41106     } catch (std::exception& e) {
41107       {
41108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41109       };
41110     } catch (Dali::DaliException e) {
41111       {
41112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41113       };
41114     } catch (...) {
41115       {
41116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41117       };
41118     }
41119   }
41120
41121 }
41122
41123
41124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41125   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41126   Dali::Radian arg2 ;
41127   Dali::Radian *argp2 ;
41128
41129   arg1 = (Dali::PanGestureDetector *)jarg1;
41130   argp2 = (Dali::Radian *)jarg2;
41131   if (!argp2) {
41132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41133     return ;
41134   }
41135   arg2 = *argp2;
41136   {
41137     try {
41138       (arg1)->RemoveAngle(arg2);
41139     } catch (std::out_of_range& e) {
41140       {
41141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41142       };
41143     } catch (std::exception& e) {
41144       {
41145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41146       };
41147     } catch (Dali::DaliException e) {
41148       {
41149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41150       };
41151     } catch (...) {
41152       {
41153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41154       };
41155     }
41156   }
41157
41158 }
41159
41160
41161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41162   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41163   Dali::Radian arg2 ;
41164   Dali::Radian *argp2 ;
41165
41166   arg1 = (Dali::PanGestureDetector *)jarg1;
41167   argp2 = (Dali::Radian *)jarg2;
41168   if (!argp2) {
41169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41170     return ;
41171   }
41172   arg2 = *argp2;
41173   {
41174     try {
41175       (arg1)->RemoveDirection(arg2);
41176     } catch (std::out_of_range& e) {
41177       {
41178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41179       };
41180     } catch (std::exception& e) {
41181       {
41182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41183       };
41184     } catch (Dali::DaliException e) {
41185       {
41186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41187       };
41188     } catch (...) {
41189       {
41190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41191       };
41192     }
41193   }
41194
41195 }
41196
41197
41198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41199   void * jresult ;
41200   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41201   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41202
41203   arg1 = (Dali::PanGestureDetector *)jarg1;
41204   {
41205     try {
41206       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41207     } catch (std::out_of_range& e) {
41208       {
41209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41210       };
41211     } catch (std::exception& e) {
41212       {
41213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41214       };
41215     } catch (Dali::DaliException e) {
41216       {
41217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41218       };
41219     } catch (...) {
41220       {
41221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41222       };
41223     }
41224   }
41225
41226   jresult = (void *)result;
41227   return jresult;
41228 }
41229
41230
41231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41232   Dali::PanGesture *arg1 = 0 ;
41233
41234   arg1 = (Dali::PanGesture *)jarg1;
41235   if (!arg1) {
41236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41237     return ;
41238   }
41239   {
41240     try {
41241       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41242     } catch (std::out_of_range& e) {
41243       {
41244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41245       };
41246     } catch (std::exception& e) {
41247       {
41248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41249       };
41250     } catch (Dali::DaliException e) {
41251       {
41252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41253       };
41254     } catch (...) {
41255       {
41256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41257       };
41258     }
41259   }
41260
41261 }
41262
41263
41264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41265   void * jresult ;
41266   Dali::PanGesture *result = 0 ;
41267
41268   {
41269     try {
41270       result = (Dali::PanGesture *)new Dali::PanGesture();
41271     } catch (std::out_of_range& e) {
41272       {
41273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41274       };
41275     } catch (std::exception& e) {
41276       {
41277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41278       };
41279     } catch (Dali::DaliException e) {
41280       {
41281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41282       };
41283     } catch (...) {
41284       {
41285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41286       };
41287     }
41288   }
41289
41290   jresult = (void *)result;
41291   return jresult;
41292 }
41293
41294
41295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41296   void * jresult ;
41297   Dali::Gesture::State arg1 ;
41298   Dali::PanGesture *result = 0 ;
41299
41300   arg1 = (Dali::Gesture::State)jarg1;
41301   {
41302     try {
41303       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41304     } catch (std::out_of_range& e) {
41305       {
41306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (std::exception& e) {
41309       {
41310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41311       };
41312     } catch (Dali::DaliException e) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41315       };
41316     } catch (...) {
41317       {
41318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41319       };
41320     }
41321   }
41322
41323   jresult = (void *)result;
41324   return jresult;
41325 }
41326
41327
41328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41329   void * jresult ;
41330   Dali::PanGesture *arg1 = 0 ;
41331   Dali::PanGesture *result = 0 ;
41332
41333   arg1 = (Dali::PanGesture *)jarg1;
41334   if (!arg1) {
41335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41336     return 0;
41337   }
41338   {
41339     try {
41340       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41341     } catch (std::out_of_range& e) {
41342       {
41343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41344       };
41345     } catch (std::exception& e) {
41346       {
41347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41348       };
41349     } catch (Dali::DaliException e) {
41350       {
41351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41352       };
41353     } catch (...) {
41354       {
41355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41356       };
41357     }
41358   }
41359
41360   jresult = (void *)result;
41361   return jresult;
41362 }
41363
41364
41365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41366   void * jresult ;
41367   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41368   Dali::PanGesture *arg2 = 0 ;
41369   Dali::PanGesture *result = 0 ;
41370
41371   arg1 = (Dali::PanGesture *)jarg1;
41372   arg2 = (Dali::PanGesture *)jarg2;
41373   if (!arg2) {
41374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41375     return 0;
41376   }
41377   {
41378     try {
41379       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41380     } catch (std::out_of_range& e) {
41381       {
41382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41383       };
41384     } catch (std::exception& e) {
41385       {
41386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41387       };
41388     } catch (Dali::DaliException e) {
41389       {
41390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41391       };
41392     } catch (...) {
41393       {
41394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41395       };
41396     }
41397   }
41398
41399   jresult = (void *)result;
41400   return jresult;
41401 }
41402
41403
41404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41405   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41406
41407   arg1 = (Dali::PanGesture *)jarg1;
41408   {
41409     try {
41410       delete arg1;
41411     } catch (std::out_of_range& e) {
41412       {
41413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41414       };
41415     } catch (std::exception& e) {
41416       {
41417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41418       };
41419     } catch (Dali::DaliException e) {
41420       {
41421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41422       };
41423     } catch (...) {
41424       {
41425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41426       };
41427     }
41428   }
41429
41430 }
41431
41432
41433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41434   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41435   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41436
41437   arg1 = (Dali::PanGesture *)jarg1;
41438   arg2 = (Dali::Vector2 *)jarg2;
41439   if (arg1) (arg1)->velocity = *arg2;
41440 }
41441
41442
41443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41444   void * jresult ;
41445   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41446   Dali::Vector2 *result = 0 ;
41447
41448   arg1 = (Dali::PanGesture *)jarg1;
41449   result = (Dali::Vector2 *)& ((arg1)->velocity);
41450   jresult = (void *)result;
41451   return jresult;
41452 }
41453
41454
41455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41456   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41457   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41458
41459   arg1 = (Dali::PanGesture *)jarg1;
41460   arg2 = (Dali::Vector2 *)jarg2;
41461   if (arg1) (arg1)->displacement = *arg2;
41462 }
41463
41464
41465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41466   void * jresult ;
41467   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41468   Dali::Vector2 *result = 0 ;
41469
41470   arg1 = (Dali::PanGesture *)jarg1;
41471   result = (Dali::Vector2 *)& ((arg1)->displacement);
41472   jresult = (void *)result;
41473   return jresult;
41474 }
41475
41476
41477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41478   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41479   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41480
41481   arg1 = (Dali::PanGesture *)jarg1;
41482   arg2 = (Dali::Vector2 *)jarg2;
41483   if (arg1) (arg1)->position = *arg2;
41484 }
41485
41486
41487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41488   void * jresult ;
41489   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41490   Dali::Vector2 *result = 0 ;
41491
41492   arg1 = (Dali::PanGesture *)jarg1;
41493   result = (Dali::Vector2 *)& ((arg1)->position);
41494   jresult = (void *)result;
41495   return jresult;
41496 }
41497
41498
41499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41500   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41501   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41502
41503   arg1 = (Dali::PanGesture *)jarg1;
41504   arg2 = (Dali::Vector2 *)jarg2;
41505   if (arg1) (arg1)->screenVelocity = *arg2;
41506 }
41507
41508
41509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41510   void * jresult ;
41511   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41512   Dali::Vector2 *result = 0 ;
41513
41514   arg1 = (Dali::PanGesture *)jarg1;
41515   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41516   jresult = (void *)result;
41517   return jresult;
41518 }
41519
41520
41521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41522   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41523   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41524
41525   arg1 = (Dali::PanGesture *)jarg1;
41526   arg2 = (Dali::Vector2 *)jarg2;
41527   if (arg1) (arg1)->screenDisplacement = *arg2;
41528 }
41529
41530
41531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41532   void * jresult ;
41533   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41534   Dali::Vector2 *result = 0 ;
41535
41536   arg1 = (Dali::PanGesture *)jarg1;
41537   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41538   jresult = (void *)result;
41539   return jresult;
41540 }
41541
41542
41543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41544   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41545   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41546
41547   arg1 = (Dali::PanGesture *)jarg1;
41548   arg2 = (Dali::Vector2 *)jarg2;
41549   if (arg1) (arg1)->screenPosition = *arg2;
41550 }
41551
41552
41553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41554   void * jresult ;
41555   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41556   Dali::Vector2 *result = 0 ;
41557
41558   arg1 = (Dali::PanGesture *)jarg1;
41559   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41560   jresult = (void *)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41566   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41567   unsigned int arg2 ;
41568
41569   arg1 = (Dali::PanGesture *)jarg1;
41570   arg2 = (unsigned int)jarg2;
41571   if (arg1) (arg1)->numberOfTouches = arg2;
41572 }
41573
41574
41575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41576   unsigned int jresult ;
41577   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41578   unsigned int result;
41579
41580   arg1 = (Dali::PanGesture *)jarg1;
41581   result = (unsigned int) ((arg1)->numberOfTouches);
41582   jresult = result;
41583   return jresult;
41584 }
41585
41586
41587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41588   float jresult ;
41589   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41590   float result;
41591
41592   arg1 = (Dali::PanGesture *)jarg1;
41593   {
41594     try {
41595       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41596     } catch (std::out_of_range& e) {
41597       {
41598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41599       };
41600     } catch (std::exception& e) {
41601       {
41602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41603       };
41604     } catch (Dali::DaliException e) {
41605       {
41606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41607       };
41608     } catch (...) {
41609       {
41610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41611       };
41612     }
41613   }
41614
41615   jresult = result;
41616   return jresult;
41617 }
41618
41619
41620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41621   float jresult ;
41622   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41623   float result;
41624
41625   arg1 = (Dali::PanGesture *)jarg1;
41626   {
41627     try {
41628       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41629     } catch (std::out_of_range& e) {
41630       {
41631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41632       };
41633     } catch (std::exception& e) {
41634       {
41635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41636       };
41637     } catch (Dali::DaliException e) {
41638       {
41639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41640       };
41641     } catch (...) {
41642       {
41643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41644       };
41645     }
41646   }
41647
41648   jresult = result;
41649   return jresult;
41650 }
41651
41652
41653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41654   float jresult ;
41655   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41656   float result;
41657
41658   arg1 = (Dali::PanGesture *)jarg1;
41659   {
41660     try {
41661       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41662     } catch (std::out_of_range& e) {
41663       {
41664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (std::exception& e) {
41667       {
41668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41669       };
41670     } catch (Dali::DaliException e) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41673       };
41674     } catch (...) {
41675       {
41676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41677       };
41678     }
41679   }
41680
41681   jresult = result;
41682   return jresult;
41683 }
41684
41685
41686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41687   float jresult ;
41688   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41689   float result;
41690
41691   arg1 = (Dali::PanGesture *)jarg1;
41692   {
41693     try {
41694       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41695     } catch (std::out_of_range& e) {
41696       {
41697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41698       };
41699     } catch (std::exception& e) {
41700       {
41701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41702       };
41703     } catch (Dali::DaliException e) {
41704       {
41705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41706       };
41707     } catch (...) {
41708       {
41709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41710       };
41711     }
41712   }
41713
41714   jresult = result;
41715   return jresult;
41716 }
41717
41718
41719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41720   void * jresult ;
41721   Dali::PinchGestureDetector *result = 0 ;
41722
41723   {
41724     try {
41725       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41726     } catch (std::out_of_range& e) {
41727       {
41728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41729       };
41730     } catch (std::exception& e) {
41731       {
41732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41733       };
41734     } catch (Dali::DaliException e) {
41735       {
41736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41737       };
41738     } catch (...) {
41739       {
41740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41741       };
41742     }
41743   }
41744
41745   jresult = (void *)result;
41746   return jresult;
41747 }
41748
41749
41750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41751   void * jresult ;
41752   Dali::PinchGestureDetector result;
41753
41754   {
41755     try {
41756       result = Dali::PinchGestureDetector::New();
41757     } catch (std::out_of_range& e) {
41758       {
41759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (std::exception& e) {
41762       {
41763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41764       };
41765     } catch (Dali::DaliException e) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41768       };
41769     } catch (...) {
41770       {
41771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41772       };
41773     }
41774   }
41775
41776   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41777   return jresult;
41778 }
41779
41780
41781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41782   void * jresult ;
41783   Dali::BaseHandle arg1 ;
41784   Dali::BaseHandle *argp1 ;
41785   Dali::PinchGestureDetector result;
41786
41787   argp1 = (Dali::BaseHandle *)jarg1;
41788   if (!argp1) {
41789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41790     return 0;
41791   }
41792   arg1 = *argp1;
41793   {
41794     try {
41795       result = Dali::PinchGestureDetector::DownCast(arg1);
41796     } catch (std::out_of_range& e) {
41797       {
41798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41799       };
41800     } catch (std::exception& e) {
41801       {
41802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41803       };
41804     } catch (Dali::DaliException e) {
41805       {
41806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41807       };
41808     } catch (...) {
41809       {
41810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41811       };
41812     }
41813   }
41814
41815   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41816   return jresult;
41817 }
41818
41819
41820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41821   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41822
41823   arg1 = (Dali::PinchGestureDetector *)jarg1;
41824   {
41825     try {
41826       delete arg1;
41827     } catch (std::out_of_range& e) {
41828       {
41829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41830       };
41831     } catch (std::exception& e) {
41832       {
41833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41834       };
41835     } catch (Dali::DaliException e) {
41836       {
41837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41838       };
41839     } catch (...) {
41840       {
41841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41842       };
41843     }
41844   }
41845
41846 }
41847
41848
41849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41850   void * jresult ;
41851   Dali::PinchGestureDetector *arg1 = 0 ;
41852   Dali::PinchGestureDetector *result = 0 ;
41853
41854   arg1 = (Dali::PinchGestureDetector *)jarg1;
41855   if (!arg1) {
41856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41857     return 0;
41858   }
41859   {
41860     try {
41861       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41862     } catch (std::out_of_range& e) {
41863       {
41864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41865       };
41866     } catch (std::exception& e) {
41867       {
41868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41869       };
41870     } catch (Dali::DaliException e) {
41871       {
41872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41873       };
41874     } catch (...) {
41875       {
41876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41877       };
41878     }
41879   }
41880
41881   jresult = (void *)result;
41882   return jresult;
41883 }
41884
41885
41886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41887   void * jresult ;
41888   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41889   Dali::PinchGestureDetector *arg2 = 0 ;
41890   Dali::PinchGestureDetector *result = 0 ;
41891
41892   arg1 = (Dali::PinchGestureDetector *)jarg1;
41893   arg2 = (Dali::PinchGestureDetector *)jarg2;
41894   if (!arg2) {
41895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41896     return 0;
41897   }
41898   {
41899     try {
41900       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41901     } catch (std::out_of_range& e) {
41902       {
41903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41904       };
41905     } catch (std::exception& e) {
41906       {
41907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41908       };
41909     } catch (Dali::DaliException e) {
41910       {
41911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41912       };
41913     } catch (...) {
41914       {
41915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41916       };
41917     }
41918   }
41919
41920   jresult = (void *)result;
41921   return jresult;
41922 }
41923
41924
41925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41926   void * jresult ;
41927   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41928   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41929
41930   arg1 = (Dali::PinchGestureDetector *)jarg1;
41931   {
41932     try {
41933       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41934     } catch (std::out_of_range& e) {
41935       {
41936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (std::exception& e) {
41939       {
41940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41941       };
41942     } catch (Dali::DaliException e) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41945       };
41946     } catch (...) {
41947       {
41948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41949       };
41950     }
41951   }
41952
41953   jresult = (void *)result;
41954   return jresult;
41955 }
41956
41957
41958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41959   void * jresult ;
41960   Dali::Gesture::State arg1 ;
41961   Dali::PinchGesture *result = 0 ;
41962
41963   arg1 = (Dali::Gesture::State)jarg1;
41964   {
41965     try {
41966       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41967     } catch (std::out_of_range& e) {
41968       {
41969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41970       };
41971     } catch (std::exception& e) {
41972       {
41973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41974       };
41975     } catch (Dali::DaliException e) {
41976       {
41977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41978       };
41979     } catch (...) {
41980       {
41981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41982       };
41983     }
41984   }
41985
41986   jresult = (void *)result;
41987   return jresult;
41988 }
41989
41990
41991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41992   void * jresult ;
41993   Dali::PinchGesture *arg1 = 0 ;
41994   Dali::PinchGesture *result = 0 ;
41995
41996   arg1 = (Dali::PinchGesture *)jarg1;
41997   if (!arg1) {
41998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41999     return 0;
42000   }
42001   {
42002     try {
42003       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42004     } catch (std::out_of_range& e) {
42005       {
42006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42007       };
42008     } catch (std::exception& e) {
42009       {
42010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42011       };
42012     } catch (Dali::DaliException e) {
42013       {
42014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42015       };
42016     } catch (...) {
42017       {
42018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42019       };
42020     }
42021   }
42022
42023   jresult = (void *)result;
42024   return jresult;
42025 }
42026
42027
42028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42029   void * jresult ;
42030   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42031   Dali::PinchGesture *arg2 = 0 ;
42032   Dali::PinchGesture *result = 0 ;
42033
42034   arg1 = (Dali::PinchGesture *)jarg1;
42035   arg2 = (Dali::PinchGesture *)jarg2;
42036   if (!arg2) {
42037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42038     return 0;
42039   }
42040   {
42041     try {
42042       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42043     } catch (std::out_of_range& e) {
42044       {
42045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42046       };
42047     } catch (std::exception& e) {
42048       {
42049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42050       };
42051     } catch (Dali::DaliException e) {
42052       {
42053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42054       };
42055     } catch (...) {
42056       {
42057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42058       };
42059     }
42060   }
42061
42062   jresult = (void *)result;
42063   return jresult;
42064 }
42065
42066
42067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42068   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42069
42070   arg1 = (Dali::PinchGesture *)jarg1;
42071   {
42072     try {
42073       delete arg1;
42074     } catch (std::out_of_range& e) {
42075       {
42076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42077       };
42078     } catch (std::exception& e) {
42079       {
42080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42081       };
42082     } catch (Dali::DaliException e) {
42083       {
42084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42085       };
42086     } catch (...) {
42087       {
42088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42089       };
42090     }
42091   }
42092
42093 }
42094
42095
42096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42097   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42098   float arg2 ;
42099
42100   arg1 = (Dali::PinchGesture *)jarg1;
42101   arg2 = (float)jarg2;
42102   if (arg1) (arg1)->scale = arg2;
42103 }
42104
42105
42106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42107   float jresult ;
42108   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42109   float result;
42110
42111   arg1 = (Dali::PinchGesture *)jarg1;
42112   result = (float) ((arg1)->scale);
42113   jresult = result;
42114   return jresult;
42115 }
42116
42117
42118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42119   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42120   float arg2 ;
42121
42122   arg1 = (Dali::PinchGesture *)jarg1;
42123   arg2 = (float)jarg2;
42124   if (arg1) (arg1)->speed = arg2;
42125 }
42126
42127
42128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42129   float jresult ;
42130   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42131   float result;
42132
42133   arg1 = (Dali::PinchGesture *)jarg1;
42134   result = (float) ((arg1)->speed);
42135   jresult = result;
42136   return jresult;
42137 }
42138
42139
42140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42141   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42142   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42143
42144   arg1 = (Dali::PinchGesture *)jarg1;
42145   arg2 = (Dali::Vector2 *)jarg2;
42146   if (arg1) (arg1)->screenCenterPoint = *arg2;
42147 }
42148
42149
42150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42151   void * jresult ;
42152   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42153   Dali::Vector2 *result = 0 ;
42154
42155   arg1 = (Dali::PinchGesture *)jarg1;
42156   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42157   jresult = (void *)result;
42158   return jresult;
42159 }
42160
42161
42162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42163   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42164   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42165
42166   arg1 = (Dali::PinchGesture *)jarg1;
42167   arg2 = (Dali::Vector2 *)jarg2;
42168   if (arg1) (arg1)->localCenterPoint = *arg2;
42169 }
42170
42171
42172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42173   void * jresult ;
42174   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42175   Dali::Vector2 *result = 0 ;
42176
42177   arg1 = (Dali::PinchGesture *)jarg1;
42178   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42179   jresult = (void *)result;
42180   return jresult;
42181 }
42182
42183
42184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42185   void * jresult ;
42186   Dali::TapGestureDetector *result = 0 ;
42187
42188   {
42189     try {
42190       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42191     } catch (std::out_of_range& e) {
42192       {
42193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42194       };
42195     } catch (std::exception& e) {
42196       {
42197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42198       };
42199     } catch (Dali::DaliException e) {
42200       {
42201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42202       };
42203     } catch (...) {
42204       {
42205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42206       };
42207     }
42208   }
42209
42210   jresult = (void *)result;
42211   return jresult;
42212 }
42213
42214
42215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42216   void * jresult ;
42217   Dali::TapGestureDetector result;
42218
42219   {
42220     try {
42221       result = Dali::TapGestureDetector::New();
42222     } catch (std::out_of_range& e) {
42223       {
42224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42225       };
42226     } catch (std::exception& e) {
42227       {
42228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42229       };
42230     } catch (Dali::DaliException e) {
42231       {
42232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42233       };
42234     } catch (...) {
42235       {
42236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42237       };
42238     }
42239   }
42240
42241   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42242   return jresult;
42243 }
42244
42245
42246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42247   void * jresult ;
42248   unsigned int arg1 ;
42249   Dali::TapGestureDetector result;
42250
42251   arg1 = (unsigned int)jarg1;
42252   {
42253     try {
42254       result = Dali::TapGestureDetector::New(arg1);
42255     } catch (std::out_of_range& e) {
42256       {
42257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42258       };
42259     } catch (std::exception& e) {
42260       {
42261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42262       };
42263     } catch (Dali::DaliException e) {
42264       {
42265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42266       };
42267     } catch (...) {
42268       {
42269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42270       };
42271     }
42272   }
42273
42274   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42275   return jresult;
42276 }
42277
42278
42279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42280   void * jresult ;
42281   Dali::BaseHandle arg1 ;
42282   Dali::BaseHandle *argp1 ;
42283   Dali::TapGestureDetector result;
42284
42285   argp1 = (Dali::BaseHandle *)jarg1;
42286   if (!argp1) {
42287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42288     return 0;
42289   }
42290   arg1 = *argp1;
42291   {
42292     try {
42293       result = Dali::TapGestureDetector::DownCast(arg1);
42294     } catch (std::out_of_range& e) {
42295       {
42296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42297       };
42298     } catch (std::exception& e) {
42299       {
42300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42301       };
42302     } catch (Dali::DaliException e) {
42303       {
42304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42305       };
42306     } catch (...) {
42307       {
42308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42309       };
42310     }
42311   }
42312
42313   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42314   return jresult;
42315 }
42316
42317
42318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42319   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42320
42321   arg1 = (Dali::TapGestureDetector *)jarg1;
42322   {
42323     try {
42324       delete arg1;
42325     } catch (std::out_of_range& e) {
42326       {
42327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42328       };
42329     } catch (std::exception& e) {
42330       {
42331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42332       };
42333     } catch (Dali::DaliException e) {
42334       {
42335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42336       };
42337     } catch (...) {
42338       {
42339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42340       };
42341     }
42342   }
42343
42344 }
42345
42346
42347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42348   void * jresult ;
42349   Dali::TapGestureDetector *arg1 = 0 ;
42350   Dali::TapGestureDetector *result = 0 ;
42351
42352   arg1 = (Dali::TapGestureDetector *)jarg1;
42353   if (!arg1) {
42354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42355     return 0;
42356   }
42357   {
42358     try {
42359       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42360     } catch (std::out_of_range& e) {
42361       {
42362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42363       };
42364     } catch (std::exception& e) {
42365       {
42366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42367       };
42368     } catch (Dali::DaliException e) {
42369       {
42370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42371       };
42372     } catch (...) {
42373       {
42374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42375       };
42376     }
42377   }
42378
42379   jresult = (void *)result;
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42385   void * jresult ;
42386   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42387   Dali::TapGestureDetector *arg2 = 0 ;
42388   Dali::TapGestureDetector *result = 0 ;
42389
42390   arg1 = (Dali::TapGestureDetector *)jarg1;
42391   arg2 = (Dali::TapGestureDetector *)jarg2;
42392   if (!arg2) {
42393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42394     return 0;
42395   }
42396   {
42397     try {
42398       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42399     } catch (std::out_of_range& e) {
42400       {
42401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42402       };
42403     } catch (std::exception& e) {
42404       {
42405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42406       };
42407     } catch (Dali::DaliException e) {
42408       {
42409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42410       };
42411     } catch (...) {
42412       {
42413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42414       };
42415     }
42416   }
42417
42418   jresult = (void *)result;
42419   return jresult;
42420 }
42421
42422
42423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42424   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42425   unsigned int arg2 ;
42426
42427   arg1 = (Dali::TapGestureDetector *)jarg1;
42428   arg2 = (unsigned int)jarg2;
42429   {
42430     try {
42431       (arg1)->SetMinimumTapsRequired(arg2);
42432     } catch (std::out_of_range& e) {
42433       {
42434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42435       };
42436     } catch (std::exception& e) {
42437       {
42438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42439       };
42440     } catch (Dali::DaliException e) {
42441       {
42442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42443       };
42444     } catch (...) {
42445       {
42446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42447       };
42448     }
42449   }
42450
42451 }
42452
42453
42454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42455   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42456   unsigned int arg2 ;
42457
42458   arg1 = (Dali::TapGestureDetector *)jarg1;
42459   arg2 = (unsigned int)jarg2;
42460   {
42461     try {
42462       (arg1)->SetMaximumTapsRequired(arg2);
42463     } catch (std::out_of_range& e) {
42464       {
42465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42466       };
42467     } catch (std::exception& e) {
42468       {
42469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42470       };
42471     } catch (Dali::DaliException e) {
42472       {
42473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42474       };
42475     } catch (...) {
42476       {
42477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42478       };
42479     }
42480   }
42481
42482 }
42483
42484
42485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42486   unsigned int jresult ;
42487   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42488   unsigned int result;
42489
42490   arg1 = (Dali::TapGestureDetector *)jarg1;
42491   {
42492     try {
42493       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42494     } catch (std::out_of_range& e) {
42495       {
42496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42497       };
42498     } catch (std::exception& e) {
42499       {
42500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42501       };
42502     } catch (Dali::DaliException e) {
42503       {
42504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42505       };
42506     } catch (...) {
42507       {
42508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42509       };
42510     }
42511   }
42512
42513   jresult = result;
42514   return jresult;
42515 }
42516
42517
42518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42519   unsigned int jresult ;
42520   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42521   unsigned int result;
42522
42523   arg1 = (Dali::TapGestureDetector *)jarg1;
42524   {
42525     try {
42526       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42527     } catch (std::out_of_range& e) {
42528       {
42529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42530       };
42531     } catch (std::exception& e) {
42532       {
42533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42534       };
42535     } catch (Dali::DaliException e) {
42536       {
42537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42538       };
42539     } catch (...) {
42540       {
42541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42542       };
42543     }
42544   }
42545
42546   jresult = result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42552   void * jresult ;
42553   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42554   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42555
42556   arg1 = (Dali::TapGestureDetector *)jarg1;
42557   {
42558     try {
42559       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42560     } catch (std::out_of_range& e) {
42561       {
42562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42563       };
42564     } catch (std::exception& e) {
42565       {
42566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42567       };
42568     } catch (Dali::DaliException e) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42575       };
42576     }
42577   }
42578
42579   jresult = (void *)result;
42580   return jresult;
42581 }
42582
42583
42584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42585   void * jresult ;
42586   Dali::TapGesture *result = 0 ;
42587
42588   {
42589     try {
42590       result = (Dali::TapGesture *)new Dali::TapGesture();
42591     } catch (std::out_of_range& e) {
42592       {
42593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42594       };
42595     } catch (std::exception& e) {
42596       {
42597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42598       };
42599     } catch (Dali::DaliException e) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42602       };
42603     } catch (...) {
42604       {
42605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42606       };
42607     }
42608   }
42609
42610   jresult = (void *)result;
42611   return jresult;
42612 }
42613
42614
42615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42616   void * jresult ;
42617   Dali::TapGesture *arg1 = 0 ;
42618   Dali::TapGesture *result = 0 ;
42619
42620   arg1 = (Dali::TapGesture *)jarg1;
42621   if (!arg1) {
42622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42623     return 0;
42624   }
42625   {
42626     try {
42627       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42628     } catch (std::out_of_range& e) {
42629       {
42630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42631       };
42632     } catch (std::exception& e) {
42633       {
42634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42635       };
42636     } catch (Dali::DaliException e) {
42637       {
42638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42639       };
42640     } catch (...) {
42641       {
42642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42643       };
42644     }
42645   }
42646
42647   jresult = (void *)result;
42648   return jresult;
42649 }
42650
42651
42652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42653   void * jresult ;
42654   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42655   Dali::TapGesture *arg2 = 0 ;
42656   Dali::TapGesture *result = 0 ;
42657
42658   arg1 = (Dali::TapGesture *)jarg1;
42659   arg2 = (Dali::TapGesture *)jarg2;
42660   if (!arg2) {
42661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42662     return 0;
42663   }
42664   {
42665     try {
42666       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42667     } catch (std::out_of_range& e) {
42668       {
42669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42670       };
42671     } catch (std::exception& e) {
42672       {
42673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42674       };
42675     } catch (Dali::DaliException e) {
42676       {
42677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42678       };
42679     } catch (...) {
42680       {
42681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42682       };
42683     }
42684   }
42685
42686   jresult = (void *)result;
42687   return jresult;
42688 }
42689
42690
42691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42692   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42693
42694   arg1 = (Dali::TapGesture *)jarg1;
42695   {
42696     try {
42697       delete arg1;
42698     } catch (std::out_of_range& e) {
42699       {
42700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42701       };
42702     } catch (std::exception& e) {
42703       {
42704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42705       };
42706     } catch (Dali::DaliException e) {
42707       {
42708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42709       };
42710     } catch (...) {
42711       {
42712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42713       };
42714     }
42715   }
42716
42717 }
42718
42719
42720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42721   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42722   unsigned int arg2 ;
42723
42724   arg1 = (Dali::TapGesture *)jarg1;
42725   arg2 = (unsigned int)jarg2;
42726   if (arg1) (arg1)->numberOfTaps = arg2;
42727 }
42728
42729
42730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42731   unsigned int jresult ;
42732   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42733   unsigned int result;
42734
42735   arg1 = (Dali::TapGesture *)jarg1;
42736   result = (unsigned int) ((arg1)->numberOfTaps);
42737   jresult = result;
42738   return jresult;
42739 }
42740
42741
42742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42743   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42744   unsigned int arg2 ;
42745
42746   arg1 = (Dali::TapGesture *)jarg1;
42747   arg2 = (unsigned int)jarg2;
42748   if (arg1) (arg1)->numberOfTouches = arg2;
42749 }
42750
42751
42752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42753   unsigned int jresult ;
42754   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42755   unsigned int result;
42756
42757   arg1 = (Dali::TapGesture *)jarg1;
42758   result = (unsigned int) ((arg1)->numberOfTouches);
42759   jresult = result;
42760   return jresult;
42761 }
42762
42763
42764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42765   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42766   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42767
42768   arg1 = (Dali::TapGesture *)jarg1;
42769   arg2 = (Dali::Vector2 *)jarg2;
42770   if (arg1) (arg1)->screenPoint = *arg2;
42771 }
42772
42773
42774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42775   void * jresult ;
42776   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42777   Dali::Vector2 *result = 0 ;
42778
42779   arg1 = (Dali::TapGesture *)jarg1;
42780   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42781   jresult = (void *)result;
42782   return jresult;
42783 }
42784
42785
42786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42787   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42788   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42789
42790   arg1 = (Dali::TapGesture *)jarg1;
42791   arg2 = (Dali::Vector2 *)jarg2;
42792   if (arg1) (arg1)->localPoint = *arg2;
42793 }
42794
42795
42796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42797   void * jresult ;
42798   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42799   Dali::Vector2 *result = 0 ;
42800
42801   arg1 = (Dali::TapGesture *)jarg1;
42802   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42803   jresult = (void *)result;
42804   return jresult;
42805 }
42806
42807
42808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42809   void * jresult ;
42810   Dali::AlphaFunction *result = 0 ;
42811
42812   {
42813     try {
42814       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42815     } catch (std::out_of_range& e) {
42816       {
42817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42818       };
42819     } catch (std::exception& e) {
42820       {
42821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42822       };
42823     } catch (Dali::DaliException e) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42826       };
42827     } catch (...) {
42828       {
42829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42830       };
42831     }
42832   }
42833
42834   jresult = (void *)result;
42835   return jresult;
42836 }
42837
42838
42839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42840   void * jresult ;
42841   Dali::AlphaFunction::BuiltinFunction arg1 ;
42842   Dali::AlphaFunction *result = 0 ;
42843
42844   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42845   {
42846     try {
42847       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42848     } catch (std::out_of_range& e) {
42849       {
42850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (std::exception& e) {
42853       {
42854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42855       };
42856     } catch (Dali::DaliException e) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42859       };
42860     } catch (...) {
42861       {
42862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42863       };
42864     }
42865   }
42866
42867   jresult = (void *)result;
42868   return jresult;
42869 }
42870
42871
42872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42873   void * jresult ;
42874   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42875   Dali::AlphaFunction *result = 0 ;
42876
42877   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42878   {
42879     try {
42880       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42881     } catch (std::out_of_range& e) {
42882       {
42883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (std::exception& e) {
42886       {
42887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (Dali::DaliException e) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42892       };
42893     } catch (...) {
42894       {
42895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42896       };
42897     }
42898   }
42899
42900   jresult = (void *)result;
42901   return jresult;
42902 }
42903
42904
42905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42906   void * jresult ;
42907   Dali::Vector2 *arg1 = 0 ;
42908   Dali::Vector2 *arg2 = 0 ;
42909   Dali::AlphaFunction *result = 0 ;
42910
42911   arg1 = (Dali::Vector2 *)jarg1;
42912   if (!arg1) {
42913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42914     return 0;
42915   }
42916   arg2 = (Dali::Vector2 *)jarg2;
42917   if (!arg2) {
42918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42919     return 0;
42920   }
42921   {
42922     try {
42923       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42924     } catch (std::out_of_range& e) {
42925       {
42926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42927       };
42928     } catch (std::exception& e) {
42929       {
42930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42931       };
42932     } catch (Dali::DaliException e) {
42933       {
42934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42935       };
42936     } catch (...) {
42937       {
42938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42939       };
42940     }
42941   }
42942
42943   jresult = (void *)result;
42944   return jresult;
42945 }
42946
42947
42948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42949   void * jresult ;
42950   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42951   Dali::Vector4 result;
42952
42953   arg1 = (Dali::AlphaFunction *)jarg1;
42954   {
42955     try {
42956       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42957     } catch (std::out_of_range& e) {
42958       {
42959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42960       };
42961     } catch (std::exception& e) {
42962       {
42963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42964       };
42965     } catch (Dali::DaliException e) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42968       };
42969     } catch (...) {
42970       {
42971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42972       };
42973     }
42974   }
42975
42976   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42977   return jresult;
42978 }
42979
42980
42981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42982   void * jresult ;
42983   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42984   Dali::AlphaFunctionPrototype result;
42985
42986   arg1 = (Dali::AlphaFunction *)jarg1;
42987   {
42988     try {
42989       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42990     } catch (std::out_of_range& e) {
42991       {
42992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42993       };
42994     } catch (std::exception& e) {
42995       {
42996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42997       };
42998     } catch (Dali::DaliException e) {
42999       {
43000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43001       };
43002     } catch (...) {
43003       {
43004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43005       };
43006     }
43007   }
43008
43009   jresult = (void *)result;
43010   return jresult;
43011 }
43012
43013
43014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43015   int jresult ;
43016   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43017   Dali::AlphaFunction::BuiltinFunction result;
43018
43019   arg1 = (Dali::AlphaFunction *)jarg1;
43020   {
43021     try {
43022       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43023     } catch (std::out_of_range& e) {
43024       {
43025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43026       };
43027     } catch (std::exception& e) {
43028       {
43029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43030       };
43031     } catch (Dali::DaliException e) {
43032       {
43033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43034       };
43035     } catch (...) {
43036       {
43037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43038       };
43039     }
43040   }
43041
43042   jresult = (int)result;
43043   return jresult;
43044 }
43045
43046
43047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43048   int jresult ;
43049   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43050   Dali::AlphaFunction::Mode result;
43051
43052   arg1 = (Dali::AlphaFunction *)jarg1;
43053   {
43054     try {
43055       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43056     } catch (std::out_of_range& e) {
43057       {
43058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (std::exception& e) {
43061       {
43062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43063       };
43064     } catch (Dali::DaliException e) {
43065       {
43066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43067       };
43068     } catch (...) {
43069       {
43070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43071       };
43072     }
43073   }
43074
43075   jresult = (int)result;
43076   return jresult;
43077 }
43078
43079
43080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43081   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43082
43083   arg1 = (Dali::AlphaFunction *)jarg1;
43084   {
43085     try {
43086       delete arg1;
43087     } catch (std::out_of_range& e) {
43088       {
43089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43090       };
43091     } catch (std::exception& e) {
43092       {
43093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43094       };
43095     } catch (Dali::DaliException e) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43098       };
43099     } catch (...) {
43100       {
43101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43102       };
43103     }
43104   }
43105
43106 }
43107
43108
43109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43110   void * jresult ;
43111   Dali::KeyFrames result;
43112
43113   {
43114     try {
43115       result = Dali::KeyFrames::New();
43116     } catch (std::out_of_range& e) {
43117       {
43118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43119       };
43120     } catch (std::exception& e) {
43121       {
43122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43123       };
43124     } catch (Dali::DaliException e) {
43125       {
43126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43127       };
43128     } catch (...) {
43129       {
43130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43131       };
43132     }
43133   }
43134
43135   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43136   return jresult;
43137 }
43138
43139
43140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43141   void * jresult ;
43142   Dali::BaseHandle arg1 ;
43143   Dali::BaseHandle *argp1 ;
43144   Dali::KeyFrames result;
43145
43146   argp1 = (Dali::BaseHandle *)jarg1;
43147   if (!argp1) {
43148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43149     return 0;
43150   }
43151   arg1 = *argp1;
43152   {
43153     try {
43154       result = Dali::KeyFrames::DownCast(arg1);
43155     } catch (std::out_of_range& e) {
43156       {
43157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (std::exception& e) {
43160       {
43161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43162       };
43163     } catch (Dali::DaliException e) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43166       };
43167     } catch (...) {
43168       {
43169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43170       };
43171     }
43172   }
43173
43174   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43175   return jresult;
43176 }
43177
43178
43179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43180   void * jresult ;
43181   Dali::KeyFrames *result = 0 ;
43182
43183   {
43184     try {
43185       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43186     } catch (std::out_of_range& e) {
43187       {
43188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43189       };
43190     } catch (std::exception& e) {
43191       {
43192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43193       };
43194     } catch (Dali::DaliException e) {
43195       {
43196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43197       };
43198     } catch (...) {
43199       {
43200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43201       };
43202     }
43203   }
43204
43205   jresult = (void *)result;
43206   return jresult;
43207 }
43208
43209
43210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43211   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43212
43213   arg1 = (Dali::KeyFrames *)jarg1;
43214   {
43215     try {
43216       delete arg1;
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43224       };
43225     } catch (Dali::DaliException e) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43228       };
43229     } catch (...) {
43230       {
43231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43232       };
43233     }
43234   }
43235
43236 }
43237
43238
43239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43240   void * jresult ;
43241   Dali::KeyFrames *arg1 = 0 ;
43242   Dali::KeyFrames *result = 0 ;
43243
43244   arg1 = (Dali::KeyFrames *)jarg1;
43245   if (!arg1) {
43246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43247     return 0;
43248   }
43249   {
43250     try {
43251       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43252     } catch (std::out_of_range& e) {
43253       {
43254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43255       };
43256     } catch (std::exception& e) {
43257       {
43258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43259       };
43260     } catch (Dali::DaliException e) {
43261       {
43262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43263       };
43264     } catch (...) {
43265       {
43266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43267       };
43268     }
43269   }
43270
43271   jresult = (void *)result;
43272   return jresult;
43273 }
43274
43275
43276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43277   void * jresult ;
43278   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43279   Dali::KeyFrames *arg2 = 0 ;
43280   Dali::KeyFrames *result = 0 ;
43281
43282   arg1 = (Dali::KeyFrames *)jarg1;
43283   arg2 = (Dali::KeyFrames *)jarg2;
43284   if (!arg2) {
43285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43286     return 0;
43287   }
43288   {
43289     try {
43290       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43291     } catch (std::out_of_range& e) {
43292       {
43293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43294       };
43295     } catch (std::exception& e) {
43296       {
43297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43298       };
43299     } catch (Dali::DaliException e) {
43300       {
43301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43302       };
43303     } catch (...) {
43304       {
43305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43306       };
43307     }
43308   }
43309
43310   jresult = (void *)result;
43311   return jresult;
43312 }
43313
43314
43315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43316   int jresult ;
43317   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43318   Dali::Property::Type result;
43319
43320   arg1 = (Dali::KeyFrames *)jarg1;
43321   {
43322     try {
43323       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43324     } catch (std::out_of_range& e) {
43325       {
43326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43327       };
43328     } catch (std::exception& e) {
43329       {
43330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43331       };
43332     } catch (Dali::DaliException e) {
43333       {
43334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43335       };
43336     } catch (...) {
43337       {
43338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43339       };
43340     }
43341   }
43342
43343   jresult = (int)result;
43344   return jresult;
43345 }
43346
43347
43348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43349   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43350   float arg2 ;
43351   Dali::Property::Value arg3 ;
43352   Dali::Property::Value *argp3 ;
43353
43354   arg1 = (Dali::KeyFrames *)jarg1;
43355   arg2 = (float)jarg2;
43356   argp3 = (Dali::Property::Value *)jarg3;
43357   if (!argp3) {
43358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43359     return ;
43360   }
43361   arg3 = *argp3;
43362   {
43363     try {
43364       (arg1)->Add(arg2,arg3);
43365     } catch (std::out_of_range& e) {
43366       {
43367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43368       };
43369     } catch (std::exception& e) {
43370       {
43371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43372       };
43373     } catch (Dali::DaliException e) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43376       };
43377     } catch (...) {
43378       {
43379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43380       };
43381     }
43382   }
43383
43384 }
43385
43386
43387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43388   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43389   float arg2 ;
43390   Dali::Property::Value arg3 ;
43391   Dali::AlphaFunction arg4 ;
43392   Dali::Property::Value *argp3 ;
43393   Dali::AlphaFunction *argp4 ;
43394
43395   arg1 = (Dali::KeyFrames *)jarg1;
43396   arg2 = (float)jarg2;
43397   argp3 = (Dali::Property::Value *)jarg3;
43398   if (!argp3) {
43399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43400     return ;
43401   }
43402   arg3 = *argp3;
43403   argp4 = (Dali::AlphaFunction *)jarg4;
43404   if (!argp4) {
43405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43406     return ;
43407   }
43408   arg4 = *argp4;
43409   {
43410     try {
43411       (arg1)->Add(arg2,arg3,arg4);
43412     } catch (std::out_of_range& e) {
43413       {
43414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43415       };
43416     } catch (std::exception& e) {
43417       {
43418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43419       };
43420     } catch (Dali::DaliException e) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43423       };
43424     } catch (...) {
43425       {
43426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43427       };
43428     }
43429   }
43430
43431 }
43432
43433
43434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43435   int jresult ;
43436   int result;
43437
43438   result = (int)Dali::Path::Property::POINTS;
43439   jresult = (int)result;
43440   return jresult;
43441 }
43442
43443
43444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43445   int jresult ;
43446   int result;
43447
43448   result = (int)Dali::Path::Property::CONTROL_POINTS;
43449   jresult = (int)result;
43450   return jresult;
43451 }
43452
43453
43454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43455   void * jresult ;
43456   Dali::Path::Property *result = 0 ;
43457
43458   {
43459     try {
43460       result = (Dali::Path::Property *)new Dali::Path::Property();
43461     } catch (std::out_of_range& e) {
43462       {
43463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43464       };
43465     } catch (std::exception& e) {
43466       {
43467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43468       };
43469     } catch (Dali::DaliException e) {
43470       {
43471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43472       };
43473     } catch (...) {
43474       {
43475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43476       };
43477     }
43478   }
43479
43480   jresult = (void *)result;
43481   return jresult;
43482 }
43483
43484
43485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43486   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43487
43488   arg1 = (Dali::Path::Property *)jarg1;
43489   {
43490     try {
43491       delete arg1;
43492     } catch (std::out_of_range& e) {
43493       {
43494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43495       };
43496     } catch (std::exception& e) {
43497       {
43498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43499       };
43500     } catch (Dali::DaliException e) {
43501       {
43502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43503       };
43504     } catch (...) {
43505       {
43506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43507       };
43508     }
43509   }
43510
43511 }
43512
43513
43514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43515   void * jresult ;
43516   Dali::Path result;
43517
43518   {
43519     try {
43520       result = Dali::Path::New();
43521     } catch (std::out_of_range& e) {
43522       {
43523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43524       };
43525     } catch (std::exception& e) {
43526       {
43527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43528       };
43529     } catch (Dali::DaliException e) {
43530       {
43531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43532       };
43533     } catch (...) {
43534       {
43535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43536       };
43537     }
43538   }
43539
43540   jresult = new Dali::Path((const Dali::Path &)result);
43541   return jresult;
43542 }
43543
43544
43545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43546   void * jresult ;
43547   Dali::BaseHandle arg1 ;
43548   Dali::BaseHandle *argp1 ;
43549   Dali::Path result;
43550
43551   argp1 = (Dali::BaseHandle *)jarg1;
43552   if (!argp1) {
43553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43554     return 0;
43555   }
43556   arg1 = *argp1;
43557   {
43558     try {
43559       result = Dali::Path::DownCast(arg1);
43560     } catch (std::out_of_range& e) {
43561       {
43562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43563       };
43564     } catch (std::exception& e) {
43565       {
43566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43567       };
43568     } catch (Dali::DaliException e) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43571       };
43572     } catch (...) {
43573       {
43574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43575       };
43576     }
43577   }
43578
43579   jresult = new Dali::Path((const Dali::Path &)result);
43580   return jresult;
43581 }
43582
43583
43584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43585   void * jresult ;
43586   Dali::Path *result = 0 ;
43587
43588   {
43589     try {
43590       result = (Dali::Path *)new Dali::Path();
43591     } catch (std::out_of_range& e) {
43592       {
43593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43594       };
43595     } catch (std::exception& e) {
43596       {
43597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43598       };
43599     } catch (Dali::DaliException e) {
43600       {
43601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43602       };
43603     } catch (...) {
43604       {
43605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43606       };
43607     }
43608   }
43609
43610   jresult = (void *)result;
43611   return jresult;
43612 }
43613
43614
43615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43616   Dali::Path *arg1 = (Dali::Path *) 0 ;
43617
43618   arg1 = (Dali::Path *)jarg1;
43619   {
43620     try {
43621       delete arg1;
43622     } catch (std::out_of_range& e) {
43623       {
43624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43625       };
43626     } catch (std::exception& e) {
43627       {
43628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43629       };
43630     } catch (Dali::DaliException e) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43633       };
43634     } catch (...) {
43635       {
43636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43637       };
43638     }
43639   }
43640
43641 }
43642
43643
43644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43645   void * jresult ;
43646   Dali::Path *arg1 = 0 ;
43647   Dali::Path *result = 0 ;
43648
43649   arg1 = (Dali::Path *)jarg1;
43650   if (!arg1) {
43651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43652     return 0;
43653   }
43654   {
43655     try {
43656       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43657     } catch (std::out_of_range& e) {
43658       {
43659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43660       };
43661     } catch (std::exception& e) {
43662       {
43663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43664       };
43665     } catch (Dali::DaliException e) {
43666       {
43667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43668       };
43669     } catch (...) {
43670       {
43671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43672       };
43673     }
43674   }
43675
43676   jresult = (void *)result;
43677   return jresult;
43678 }
43679
43680
43681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43682   void * jresult ;
43683   Dali::Path *arg1 = (Dali::Path *) 0 ;
43684   Dali::Path *arg2 = 0 ;
43685   Dali::Path *result = 0 ;
43686
43687   arg1 = (Dali::Path *)jarg1;
43688   arg2 = (Dali::Path *)jarg2;
43689   if (!arg2) {
43690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43691     return 0;
43692   }
43693   {
43694     try {
43695       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43696     } catch (std::out_of_range& e) {
43697       {
43698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43699       };
43700     } catch (std::exception& e) {
43701       {
43702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43703       };
43704     } catch (Dali::DaliException e) {
43705       {
43706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43707       };
43708     } catch (...) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43711       };
43712     }
43713   }
43714
43715   jresult = (void *)result;
43716   return jresult;
43717 }
43718
43719
43720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43721   Dali::Path *arg1 = (Dali::Path *) 0 ;
43722   Dali::Vector3 *arg2 = 0 ;
43723
43724   arg1 = (Dali::Path *)jarg1;
43725   arg2 = (Dali::Vector3 *)jarg2;
43726   if (!arg2) {
43727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43728     return ;
43729   }
43730   {
43731     try {
43732       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43733     } catch (std::out_of_range& e) {
43734       {
43735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43736       };
43737     } catch (std::exception& e) {
43738       {
43739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43740       };
43741     } catch (Dali::DaliException e) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43744       };
43745     } catch (...) {
43746       {
43747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43748       };
43749     }
43750   }
43751
43752 }
43753
43754
43755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43756   Dali::Path *arg1 = (Dali::Path *) 0 ;
43757   Dali::Vector3 *arg2 = 0 ;
43758
43759   arg1 = (Dali::Path *)jarg1;
43760   arg2 = (Dali::Vector3 *)jarg2;
43761   if (!arg2) {
43762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43763     return ;
43764   }
43765   {
43766     try {
43767       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43768     } catch (std::out_of_range& e) {
43769       {
43770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43771       };
43772     } catch (std::exception& e) {
43773       {
43774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43775       };
43776     } catch (Dali::DaliException e) {
43777       {
43778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43779       };
43780     } catch (...) {
43781       {
43782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43783       };
43784     }
43785   }
43786
43787 }
43788
43789
43790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43791   Dali::Path *arg1 = (Dali::Path *) 0 ;
43792   float arg2 ;
43793
43794   arg1 = (Dali::Path *)jarg1;
43795   arg2 = (float)jarg2;
43796   {
43797     try {
43798       (arg1)->GenerateControlPoints(arg2);
43799     } catch (std::out_of_range& e) {
43800       {
43801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43802       };
43803     } catch (std::exception& e) {
43804       {
43805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43806       };
43807     } catch (Dali::DaliException e) {
43808       {
43809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43810       };
43811     } catch (...) {
43812       {
43813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43814       };
43815     }
43816   }
43817
43818 }
43819
43820
43821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43822   Dali::Path *arg1 = (Dali::Path *) 0 ;
43823   float arg2 ;
43824   Dali::Vector3 *arg3 = 0 ;
43825   Dali::Vector3 *arg4 = 0 ;
43826
43827   arg1 = (Dali::Path *)jarg1;
43828   arg2 = (float)jarg2;
43829   arg3 = (Dali::Vector3 *)jarg3;
43830   if (!arg3) {
43831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43832     return ;
43833   }
43834   arg4 = (Dali::Vector3 *)jarg4;
43835   if (!arg4) {
43836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43837     return ;
43838   }
43839   {
43840     try {
43841       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43842     } catch (std::out_of_range& e) {
43843       {
43844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43845       };
43846     } catch (std::exception& e) {
43847       {
43848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43849       };
43850     } catch (Dali::DaliException e) {
43851       {
43852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43853       };
43854     } catch (...) {
43855       {
43856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43857       };
43858     }
43859   }
43860
43861 }
43862
43863
43864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43865   void * jresult ;
43866   Dali::Path *arg1 = (Dali::Path *) 0 ;
43867   size_t arg2 ;
43868   Dali::Vector3 *result = 0 ;
43869
43870   arg1 = (Dali::Path *)jarg1;
43871   arg2 = (size_t)jarg2;
43872   {
43873     try {
43874       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43875     } catch (std::out_of_range& e) {
43876       {
43877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43878       };
43879     } catch (std::exception& e) {
43880       {
43881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43882       };
43883     } catch (Dali::DaliException e) {
43884       {
43885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43886       };
43887     } catch (...) {
43888       {
43889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43890       };
43891     }
43892   }
43893
43894   jresult = (void *)result;
43895   return jresult;
43896 }
43897
43898
43899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43900   void * jresult ;
43901   Dali::Path *arg1 = (Dali::Path *) 0 ;
43902   size_t arg2 ;
43903   Dali::Vector3 *result = 0 ;
43904
43905   arg1 = (Dali::Path *)jarg1;
43906   arg2 = (size_t)jarg2;
43907   {
43908     try {
43909       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43910     } catch (std::out_of_range& e) {
43911       {
43912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43913       };
43914     } catch (std::exception& e) {
43915       {
43916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43917       };
43918     } catch (Dali::DaliException e) {
43919       {
43920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43921       };
43922     } catch (...) {
43923       {
43924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43925       };
43926     }
43927   }
43928
43929   jresult = (void *)result;
43930   return jresult;
43931 }
43932
43933
43934 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43935   unsigned long jresult ;
43936   Dali::Path *arg1 = (Dali::Path *) 0 ;
43937   size_t result;
43938
43939   arg1 = (Dali::Path *)jarg1;
43940   {
43941     try {
43942       result = ((Dali::Path const *)arg1)->GetPointCount();
43943     } catch (std::out_of_range& e) {
43944       {
43945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (std::exception& e) {
43948       {
43949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43950       };
43951     } catch (Dali::DaliException e) {
43952       {
43953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43954       };
43955     } catch (...) {
43956       {
43957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43958       };
43959     }
43960   }
43961
43962   jresult = (unsigned long)result;
43963   return jresult;
43964 }
43965
43966
43967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43968   void * jresult ;
43969   float arg1 ;
43970   Dali::TimePeriod *result = 0 ;
43971
43972   arg1 = (float)jarg1;
43973   {
43974     try {
43975       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43976     } catch (std::out_of_range& e) {
43977       {
43978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43979       };
43980     } catch (std::exception& e) {
43981       {
43982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43983       };
43984     } catch (Dali::DaliException e) {
43985       {
43986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43987       };
43988     } catch (...) {
43989       {
43990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43991       };
43992     }
43993   }
43994
43995   jresult = (void *)result;
43996   return jresult;
43997 }
43998
43999
44000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44001   void * jresult ;
44002   float arg1 ;
44003   float arg2 ;
44004   Dali::TimePeriod *result = 0 ;
44005
44006   arg1 = (float)jarg1;
44007   arg2 = (float)jarg2;
44008   {
44009     try {
44010       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44011     } catch (std::out_of_range& e) {
44012       {
44013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44014       };
44015     } catch (std::exception& e) {
44016       {
44017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44018       };
44019     } catch (Dali::DaliException e) {
44020       {
44021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44022       };
44023     } catch (...) {
44024       {
44025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44026       };
44027     }
44028   }
44029
44030   jresult = (void *)result;
44031   return jresult;
44032 }
44033
44034
44035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44036   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44037
44038   arg1 = (Dali::TimePeriod *)jarg1;
44039   {
44040     try {
44041       delete arg1;
44042     } catch (std::out_of_range& e) {
44043       {
44044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44045       };
44046     } catch (std::exception& e) {
44047       {
44048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44049       };
44050     } catch (Dali::DaliException e) {
44051       {
44052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44053       };
44054     } catch (...) {
44055       {
44056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44057       };
44058     }
44059   }
44060
44061 }
44062
44063
44064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44065   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44066   float arg2 ;
44067
44068   arg1 = (Dali::TimePeriod *)jarg1;
44069   arg2 = (float)jarg2;
44070   if (arg1) (arg1)->delaySeconds = arg2;
44071 }
44072
44073
44074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44075   float jresult ;
44076   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44077   float result;
44078
44079   arg1 = (Dali::TimePeriod *)jarg1;
44080   result = (float) ((arg1)->delaySeconds);
44081   jresult = result;
44082   return jresult;
44083 }
44084
44085
44086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44087   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44088   float arg2 ;
44089
44090   arg1 = (Dali::TimePeriod *)jarg1;
44091   arg2 = (float)jarg2;
44092   if (arg1) (arg1)->durationSeconds = arg2;
44093 }
44094
44095
44096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44097   float jresult ;
44098   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44099   float result;
44100
44101   arg1 = (Dali::TimePeriod *)jarg1;
44102   result = (float) ((arg1)->durationSeconds);
44103   jresult = result;
44104   return jresult;
44105 }
44106
44107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44108   int jresult ;
44109   int result;
44110
44111   result = (int)Dali::LinearConstrainer::Property::VALUE;
44112   jresult = (int)result;
44113   return jresult;
44114 }
44115
44116
44117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44118   int jresult ;
44119   int result;
44120
44121   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44122   jresult = (int)result;
44123   return jresult;
44124 }
44125
44126
44127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44128   void * jresult ;
44129   Dali::LinearConstrainer::Property *result = 0 ;
44130
44131   {
44132     try {
44133       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44134     } catch (std::out_of_range& e) {
44135       {
44136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44137       };
44138     } catch (std::exception& e) {
44139       {
44140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44141       };
44142     } catch (Dali::DaliException e) {
44143       {
44144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44145       };
44146     } catch (...) {
44147       {
44148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44149       };
44150     }
44151   }
44152
44153   jresult = (void *)result;
44154   return jresult;
44155 }
44156
44157
44158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44159   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44160
44161   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44162   {
44163     try {
44164       delete arg1;
44165     } catch (std::out_of_range& e) {
44166       {
44167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44168       };
44169     } catch (std::exception& e) {
44170       {
44171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44172       };
44173     } catch (Dali::DaliException e) {
44174       {
44175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44176       };
44177     } catch (...) {
44178       {
44179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44180       };
44181     }
44182   }
44183
44184 }
44185
44186
44187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44188   void * jresult ;
44189   Dali::LinearConstrainer result;
44190
44191   {
44192     try {
44193       result = Dali::LinearConstrainer::New();
44194     } catch (std::out_of_range& e) {
44195       {
44196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44197       };
44198     } catch (std::exception& e) {
44199       {
44200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44201       };
44202     } catch (Dali::DaliException e) {
44203       {
44204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44205       };
44206     } catch (...) {
44207       {
44208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44209       };
44210     }
44211   }
44212
44213   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44214   return jresult;
44215 }
44216
44217
44218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44219   void * jresult ;
44220   Dali::BaseHandle arg1 ;
44221   Dali::BaseHandle *argp1 ;
44222   Dali::LinearConstrainer result;
44223
44224   argp1 = (Dali::BaseHandle *)jarg1;
44225   if (!argp1) {
44226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44227     return 0;
44228   }
44229   arg1 = *argp1;
44230   {
44231     try {
44232       result = Dali::LinearConstrainer::DownCast(arg1);
44233     } catch (std::out_of_range& e) {
44234       {
44235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44236       };
44237     } catch (std::exception& e) {
44238       {
44239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44240       };
44241     } catch (Dali::DaliException e) {
44242       {
44243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44244       };
44245     } catch (...) {
44246       {
44247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44248       };
44249     }
44250   }
44251
44252   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44253   return jresult;
44254 }
44255
44256
44257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44258   void * jresult ;
44259   Dali::LinearConstrainer *result = 0 ;
44260
44261   {
44262     try {
44263       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44264     } catch (std::out_of_range& e) {
44265       {
44266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44267       };
44268     } catch (std::exception& e) {
44269       {
44270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44271       };
44272     } catch (Dali::DaliException e) {
44273       {
44274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44275       };
44276     } catch (...) {
44277       {
44278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44279       };
44280     }
44281   }
44282
44283   jresult = (void *)result;
44284   return jresult;
44285 }
44286
44287
44288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44289   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44290
44291   arg1 = (Dali::LinearConstrainer *)jarg1;
44292   {
44293     try {
44294       delete arg1;
44295     } catch (std::out_of_range& e) {
44296       {
44297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44298       };
44299     } catch (std::exception& e) {
44300       {
44301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44302       };
44303     } catch (Dali::DaliException e) {
44304       {
44305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44306       };
44307     } catch (...) {
44308       {
44309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44310       };
44311     }
44312   }
44313
44314 }
44315
44316
44317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44318   void * jresult ;
44319   Dali::LinearConstrainer *arg1 = 0 ;
44320   Dali::LinearConstrainer *result = 0 ;
44321
44322   arg1 = (Dali::LinearConstrainer *)jarg1;
44323   if (!arg1) {
44324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44325     return 0;
44326   }
44327   {
44328     try {
44329       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44330     } catch (std::out_of_range& e) {
44331       {
44332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44333       };
44334     } catch (std::exception& e) {
44335       {
44336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44337       };
44338     } catch (Dali::DaliException e) {
44339       {
44340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44341       };
44342     } catch (...) {
44343       {
44344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44345       };
44346     }
44347   }
44348
44349   jresult = (void *)result;
44350   return jresult;
44351 }
44352
44353
44354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44355   void * jresult ;
44356   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44357   Dali::LinearConstrainer *arg2 = 0 ;
44358   Dali::LinearConstrainer *result = 0 ;
44359
44360   arg1 = (Dali::LinearConstrainer *)jarg1;
44361   arg2 = (Dali::LinearConstrainer *)jarg2;
44362   if (!arg2) {
44363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44364     return 0;
44365   }
44366   {
44367     try {
44368       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44369     } catch (std::out_of_range& e) {
44370       {
44371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44372       };
44373     } catch (std::exception& e) {
44374       {
44375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44376       };
44377     } catch (Dali::DaliException e) {
44378       {
44379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44380       };
44381     } catch (...) {
44382       {
44383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44384       };
44385     }
44386   }
44387
44388   jresult = (void *)result;
44389   return jresult;
44390 }
44391
44392
44393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44394   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44395   SwigValueWrapper< Dali::Property > arg2 ;
44396   SwigValueWrapper< Dali::Property > arg3 ;
44397   Dali::Vector2 *arg4 = 0 ;
44398   Dali::Vector2 *arg5 = 0 ;
44399   Dali::Property *argp2 ;
44400   Dali::Property *argp3 ;
44401
44402   arg1 = (Dali::LinearConstrainer *)jarg1;
44403   argp2 = (Dali::Property *)jarg2;
44404   if (!argp2) {
44405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44406     return ;
44407   }
44408   arg2 = *argp2;
44409   argp3 = (Dali::Property *)jarg3;
44410   if (!argp3) {
44411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44412     return ;
44413   }
44414   arg3 = *argp3;
44415   arg4 = (Dali::Vector2 *)jarg4;
44416   if (!arg4) {
44417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44418     return ;
44419   }
44420   arg5 = (Dali::Vector2 *)jarg5;
44421   if (!arg5) {
44422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44423     return ;
44424   }
44425   {
44426     try {
44427       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44428     } catch (std::out_of_range& e) {
44429       {
44430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44431       };
44432     } catch (std::exception& e) {
44433       {
44434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44435       };
44436     } catch (Dali::DaliException e) {
44437       {
44438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44439       };
44440     } catch (...) {
44441       {
44442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44443       };
44444     }
44445   }
44446
44447 }
44448
44449
44450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44451   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44452   SwigValueWrapper< Dali::Property > arg2 ;
44453   SwigValueWrapper< Dali::Property > arg3 ;
44454   Dali::Vector2 *arg4 = 0 ;
44455   Dali::Property *argp2 ;
44456   Dali::Property *argp3 ;
44457
44458   arg1 = (Dali::LinearConstrainer *)jarg1;
44459   argp2 = (Dali::Property *)jarg2;
44460   if (!argp2) {
44461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44462     return ;
44463   }
44464   arg2 = *argp2;
44465   argp3 = (Dali::Property *)jarg3;
44466   if (!argp3) {
44467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44468     return ;
44469   }
44470   arg3 = *argp3;
44471   arg4 = (Dali::Vector2 *)jarg4;
44472   if (!arg4) {
44473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44474     return ;
44475   }
44476   {
44477     try {
44478       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44479     } catch (std::out_of_range& e) {
44480       {
44481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44482       };
44483     } catch (std::exception& e) {
44484       {
44485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44486       };
44487     } catch (Dali::DaliException e) {
44488       {
44489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44490       };
44491     } catch (...) {
44492       {
44493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44494       };
44495     }
44496   }
44497
44498 }
44499
44500
44501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44502   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44503   Dali::Handle *arg2 = 0 ;
44504
44505   arg1 = (Dali::LinearConstrainer *)jarg1;
44506   arg2 = (Dali::Handle *)jarg2;
44507   if (!arg2) {
44508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44509     return ;
44510   }
44511   {
44512     try {
44513       (arg1)->Remove(*arg2);
44514     } catch (std::out_of_range& e) {
44515       {
44516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44517       };
44518     } catch (std::exception& e) {
44519       {
44520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44521       };
44522     } catch (Dali::DaliException e) {
44523       {
44524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44525       };
44526     } catch (...) {
44527       {
44528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44529       };
44530     }
44531   }
44532
44533 }
44534
44535
44536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44537   int jresult ;
44538   int result;
44539
44540   result = (int)Dali::PathConstrainer::Property::FORWARD;
44541   jresult = (int)result;
44542   return jresult;
44543 }
44544
44545
44546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44547   int jresult ;
44548   int result;
44549
44550   result = (int)Dali::PathConstrainer::Property::POINTS;
44551   jresult = (int)result;
44552   return jresult;
44553 }
44554
44555
44556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44557   int jresult ;
44558   int result;
44559
44560   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44561   jresult = (int)result;
44562   return jresult;
44563 }
44564
44565
44566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44567   void * jresult ;
44568   Dali::PathConstrainer::Property *result = 0 ;
44569
44570   {
44571     try {
44572       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44573     } catch (std::out_of_range& e) {
44574       {
44575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44576       };
44577     } catch (std::exception& e) {
44578       {
44579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44580       };
44581     } catch (Dali::DaliException e) {
44582       {
44583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44584       };
44585     } catch (...) {
44586       {
44587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44588       };
44589     }
44590   }
44591
44592   jresult = (void *)result;
44593   return jresult;
44594 }
44595
44596
44597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44598   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44599
44600   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44601   {
44602     try {
44603       delete arg1;
44604     } catch (std::out_of_range& e) {
44605       {
44606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44607       };
44608     } catch (std::exception& e) {
44609       {
44610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44611       };
44612     } catch (Dali::DaliException e) {
44613       {
44614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44615       };
44616     } catch (...) {
44617       {
44618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44619       };
44620     }
44621   }
44622
44623 }
44624
44625
44626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44627   void * jresult ;
44628   Dali::PathConstrainer result;
44629
44630   {
44631     try {
44632       result = Dali::PathConstrainer::New();
44633     } catch (std::out_of_range& e) {
44634       {
44635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44636       };
44637     } catch (std::exception& e) {
44638       {
44639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44640       };
44641     } catch (Dali::DaliException e) {
44642       {
44643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44644       };
44645     } catch (...) {
44646       {
44647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44648       };
44649     }
44650   }
44651
44652   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44653   return jresult;
44654 }
44655
44656
44657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44658   void * jresult ;
44659   Dali::BaseHandle arg1 ;
44660   Dali::BaseHandle *argp1 ;
44661   Dali::PathConstrainer result;
44662
44663   argp1 = (Dali::BaseHandle *)jarg1;
44664   if (!argp1) {
44665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44666     return 0;
44667   }
44668   arg1 = *argp1;
44669   {
44670     try {
44671       result = Dali::PathConstrainer::DownCast(arg1);
44672     } catch (std::out_of_range& e) {
44673       {
44674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44675       };
44676     } catch (std::exception& e) {
44677       {
44678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44679       };
44680     } catch (Dali::DaliException e) {
44681       {
44682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44683       };
44684     } catch (...) {
44685       {
44686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44687       };
44688     }
44689   }
44690
44691   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44692   return jresult;
44693 }
44694
44695
44696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44697   void * jresult ;
44698   Dali::PathConstrainer *result = 0 ;
44699
44700   {
44701     try {
44702       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44703     } catch (std::out_of_range& e) {
44704       {
44705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44706       };
44707     } catch (std::exception& e) {
44708       {
44709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44710       };
44711     } catch (Dali::DaliException e) {
44712       {
44713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44714       };
44715     } catch (...) {
44716       {
44717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44718       };
44719     }
44720   }
44721
44722   jresult = (void *)result;
44723   return jresult;
44724 }
44725
44726
44727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44728   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44729
44730   arg1 = (Dali::PathConstrainer *)jarg1;
44731   {
44732     try {
44733       delete arg1;
44734     } catch (std::out_of_range& e) {
44735       {
44736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44737       };
44738     } catch (std::exception& e) {
44739       {
44740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44741       };
44742     } catch (Dali::DaliException e) {
44743       {
44744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44745       };
44746     } catch (...) {
44747       {
44748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44749       };
44750     }
44751   }
44752
44753 }
44754
44755
44756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44757   void * jresult ;
44758   Dali::PathConstrainer *arg1 = 0 ;
44759   Dali::PathConstrainer *result = 0 ;
44760
44761   arg1 = (Dali::PathConstrainer *)jarg1;
44762   if (!arg1) {
44763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44764     return 0;
44765   }
44766   {
44767     try {
44768       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44769     } catch (std::out_of_range& e) {
44770       {
44771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44772       };
44773     } catch (std::exception& e) {
44774       {
44775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44776       };
44777     } catch (Dali::DaliException e) {
44778       {
44779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44780       };
44781     } catch (...) {
44782       {
44783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44784       };
44785     }
44786   }
44787
44788   jresult = (void *)result;
44789   return jresult;
44790 }
44791
44792
44793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44794   void * jresult ;
44795   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44796   Dali::PathConstrainer *arg2 = 0 ;
44797   Dali::PathConstrainer *result = 0 ;
44798
44799   arg1 = (Dali::PathConstrainer *)jarg1;
44800   arg2 = (Dali::PathConstrainer *)jarg2;
44801   if (!arg2) {
44802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44803     return 0;
44804   }
44805   {
44806     try {
44807       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44808     } catch (std::out_of_range& e) {
44809       {
44810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44811       };
44812     } catch (std::exception& e) {
44813       {
44814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44815       };
44816     } catch (Dali::DaliException e) {
44817       {
44818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44819       };
44820     } catch (...) {
44821       {
44822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44823       };
44824     }
44825   }
44826
44827   jresult = (void *)result;
44828   return jresult;
44829 }
44830
44831
44832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44833   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44834   SwigValueWrapper< Dali::Property > arg2 ;
44835   SwigValueWrapper< Dali::Property > arg3 ;
44836   Dali::Vector2 *arg4 = 0 ;
44837   Dali::Vector2 *arg5 = 0 ;
44838   Dali::Property *argp2 ;
44839   Dali::Property *argp3 ;
44840
44841   arg1 = (Dali::PathConstrainer *)jarg1;
44842   argp2 = (Dali::Property *)jarg2;
44843   if (!argp2) {
44844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44845     return ;
44846   }
44847   arg2 = *argp2;
44848   argp3 = (Dali::Property *)jarg3;
44849   if (!argp3) {
44850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44851     return ;
44852   }
44853   arg3 = *argp3;
44854   arg4 = (Dali::Vector2 *)jarg4;
44855   if (!arg4) {
44856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44857     return ;
44858   }
44859   arg5 = (Dali::Vector2 *)jarg5;
44860   if (!arg5) {
44861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44862     return ;
44863   }
44864   {
44865     try {
44866       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44867     } catch (std::out_of_range& e) {
44868       {
44869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44870       };
44871     } catch (std::exception& e) {
44872       {
44873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44874       };
44875     } catch (Dali::DaliException e) {
44876       {
44877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44878       };
44879     } catch (...) {
44880       {
44881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44882       };
44883     }
44884   }
44885
44886 }
44887
44888
44889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44890   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44891   SwigValueWrapper< Dali::Property > arg2 ;
44892   SwigValueWrapper< Dali::Property > arg3 ;
44893   Dali::Vector2 *arg4 = 0 ;
44894   Dali::Property *argp2 ;
44895   Dali::Property *argp3 ;
44896
44897   arg1 = (Dali::PathConstrainer *)jarg1;
44898   argp2 = (Dali::Property *)jarg2;
44899   if (!argp2) {
44900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44901     return ;
44902   }
44903   arg2 = *argp2;
44904   argp3 = (Dali::Property *)jarg3;
44905   if (!argp3) {
44906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44907     return ;
44908   }
44909   arg3 = *argp3;
44910   arg4 = (Dali::Vector2 *)jarg4;
44911   if (!arg4) {
44912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44913     return ;
44914   }
44915   {
44916     try {
44917       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44918     } catch (std::out_of_range& e) {
44919       {
44920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44921       };
44922     } catch (std::exception& e) {
44923       {
44924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44925       };
44926     } catch (Dali::DaliException e) {
44927       {
44928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44929       };
44930     } catch (...) {
44931       {
44932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44933       };
44934     }
44935   }
44936
44937 }
44938
44939
44940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44941   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44942   Dali::Handle *arg2 = 0 ;
44943
44944   arg1 = (Dali::PathConstrainer *)jarg1;
44945   arg2 = (Dali::Handle *)jarg2;
44946   if (!arg2) {
44947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44948     return ;
44949   }
44950   {
44951     try {
44952       (arg1)->Remove(*arg2);
44953     } catch (std::out_of_range& e) {
44954       {
44955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44956       };
44957     } catch (std::exception& e) {
44958       {
44959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44960       };
44961     } catch (Dali::DaliException e) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44964       };
44965     } catch (...) {
44966       {
44967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44968       };
44969     }
44970   }
44971
44972 }
44973
44974
44975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44976   int jresult ;
44977   Dali::FittingMode::Type result;
44978
44979   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44980   jresult = (int)result;
44981   return jresult;
44982 }
44983
44984
44985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44986   int jresult ;
44987   Dali::SamplingMode::Type result;
44988
44989   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44990   jresult = (int)result;
44991   return jresult;
44992 }
44993
44994
44995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44996   void * jresult ;
44997   Dali::BufferImage *result = 0 ;
44998
44999   {
45000     try {
45001       result = (Dali::BufferImage *)new Dali::BufferImage();
45002     } catch (std::out_of_range& e) {
45003       {
45004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45005       };
45006     } catch (std::exception& e) {
45007       {
45008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45009       };
45010     } catch (Dali::DaliException e) {
45011       {
45012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45013       };
45014     } catch (...) {
45015       {
45016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45017       };
45018     }
45019   }
45020
45021   jresult = (void *)result;
45022   return jresult;
45023 }
45024
45025
45026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45027   void * jresult ;
45028   unsigned int arg1 ;
45029   unsigned int arg2 ;
45030   Dali::Pixel::Format arg3 ;
45031   Dali::BufferImage result;
45032
45033   arg1 = (unsigned int)jarg1;
45034   arg2 = (unsigned int)jarg2;
45035   arg3 = (Dali::Pixel::Format)jarg3;
45036   {
45037     try {
45038       result = Dali::BufferImage::New(arg1,arg2,arg3);
45039     } catch (std::out_of_range& e) {
45040       {
45041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45042       };
45043     } catch (std::exception& e) {
45044       {
45045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45046       };
45047     } catch (Dali::DaliException e) {
45048       {
45049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45050       };
45051     } catch (...) {
45052       {
45053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45054       };
45055     }
45056   }
45057
45058   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45059   return jresult;
45060 }
45061
45062
45063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45064   void * jresult ;
45065   unsigned int arg1 ;
45066   unsigned int arg2 ;
45067   Dali::BufferImage result;
45068
45069   arg1 = (unsigned int)jarg1;
45070   arg2 = (unsigned int)jarg2;
45071   {
45072     try {
45073       result = Dali::BufferImage::New(arg1,arg2);
45074     } catch (std::out_of_range& e) {
45075       {
45076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45077       };
45078     } catch (std::exception& e) {
45079       {
45080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45081       };
45082     } catch (Dali::DaliException e) {
45083       {
45084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45085       };
45086     } catch (...) {
45087       {
45088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45089       };
45090     }
45091   }
45092
45093   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45094   return jresult;
45095 }
45096
45097
45098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45099   void * jresult ;
45100   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45101   unsigned int arg2 ;
45102   unsigned int arg3 ;
45103   Dali::Pixel::Format arg4 ;
45104   unsigned int arg5 ;
45105   Dali::BufferImage result;
45106
45107   arg1 = jarg1;
45108   arg2 = (unsigned int)jarg2;
45109   arg3 = (unsigned int)jarg3;
45110   arg4 = (Dali::Pixel::Format)jarg4;
45111   arg5 = (unsigned int)jarg5;
45112   {
45113     try {
45114       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45115     } catch (std::out_of_range& e) {
45116       {
45117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45118       };
45119     } catch (std::exception& e) {
45120       {
45121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45122       };
45123     } catch (Dali::DaliException e) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45126       };
45127     } catch (...) {
45128       {
45129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45130       };
45131     }
45132   }
45133
45134   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45135
45136
45137   return jresult;
45138 }
45139
45140
45141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45142   void * jresult ;
45143   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45144   unsigned int arg2 ;
45145   unsigned int arg3 ;
45146   Dali::Pixel::Format arg4 ;
45147   Dali::BufferImage result;
45148
45149   arg1 = jarg1;
45150   arg2 = (unsigned int)jarg2;
45151   arg3 = (unsigned int)jarg3;
45152   arg4 = (Dali::Pixel::Format)jarg4;
45153   {
45154     try {
45155       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45156     } catch (std::out_of_range& e) {
45157       {
45158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45159       };
45160     } catch (std::exception& e) {
45161       {
45162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45163       };
45164     } catch (Dali::DaliException e) {
45165       {
45166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45167       };
45168     } catch (...) {
45169       {
45170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45171       };
45172     }
45173   }
45174
45175   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45176
45177
45178   return jresult;
45179 }
45180
45181
45182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45183   void * jresult ;
45184   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45185   unsigned int arg2 ;
45186   unsigned int arg3 ;
45187   Dali::BufferImage result;
45188
45189   arg1 = jarg1;
45190   arg2 = (unsigned int)jarg2;
45191   arg3 = (unsigned int)jarg3;
45192   {
45193     try {
45194       result = Dali::BufferImage::New(arg1,arg2,arg3);
45195     } catch (std::out_of_range& e) {
45196       {
45197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45198       };
45199     } catch (std::exception& e) {
45200       {
45201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45202       };
45203     } catch (Dali::DaliException e) {
45204       {
45205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45206       };
45207     } catch (...) {
45208       {
45209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45210       };
45211     }
45212   }
45213
45214   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45215
45216
45217   return jresult;
45218 }
45219
45220
45221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45222   void * jresult ;
45223   Dali::BaseHandle arg1 ;
45224   Dali::BaseHandle *argp1 ;
45225   Dali::BufferImage result;
45226
45227   argp1 = (Dali::BaseHandle *)jarg1;
45228   if (!argp1) {
45229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45230     return 0;
45231   }
45232   arg1 = *argp1;
45233   {
45234     try {
45235       result = Dali::BufferImage::DownCast(arg1);
45236     } catch (std::out_of_range& e) {
45237       {
45238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45239       };
45240     } catch (std::exception& e) {
45241       {
45242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45243       };
45244     } catch (Dali::DaliException e) {
45245       {
45246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45247       };
45248     } catch (...) {
45249       {
45250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45251       };
45252     }
45253   }
45254
45255   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45256   return jresult;
45257 }
45258
45259
45260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45261   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45262
45263   arg1 = (Dali::BufferImage *)jarg1;
45264   {
45265     try {
45266       delete arg1;
45267     } catch (std::out_of_range& e) {
45268       {
45269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45270       };
45271     } catch (std::exception& e) {
45272       {
45273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45274       };
45275     } catch (Dali::DaliException e) {
45276       {
45277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45278       };
45279     } catch (...) {
45280       {
45281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45282       };
45283     }
45284   }
45285
45286 }
45287
45288
45289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45290   void * jresult ;
45291   Dali::BufferImage *arg1 = 0 ;
45292   Dali::BufferImage *result = 0 ;
45293
45294   arg1 = (Dali::BufferImage *)jarg1;
45295   if (!arg1) {
45296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45297     return 0;
45298   }
45299   {
45300     try {
45301       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45302     } catch (std::out_of_range& e) {
45303       {
45304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45305       };
45306     } catch (std::exception& e) {
45307       {
45308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45309       };
45310     } catch (Dali::DaliException e) {
45311       {
45312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45313       };
45314     } catch (...) {
45315       {
45316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45317       };
45318     }
45319   }
45320
45321   jresult = (void *)result;
45322   return jresult;
45323 }
45324
45325
45326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45327   void * jresult ;
45328   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45329   Dali::BufferImage *arg2 = 0 ;
45330   Dali::BufferImage *result = 0 ;
45331
45332   arg1 = (Dali::BufferImage *)jarg1;
45333   arg2 = (Dali::BufferImage *)jarg2;
45334   if (!arg2) {
45335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45336     return 0;
45337   }
45338   {
45339     try {
45340       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45341     } catch (std::out_of_range& e) {
45342       {
45343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (std::exception& e) {
45346       {
45347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45348       };
45349     } catch (Dali::DaliException e) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45352       };
45353     } catch (...) {
45354       {
45355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45356       };
45357     }
45358   }
45359
45360   jresult = (void *)result;
45361   return jresult;
45362 }
45363
45364
45365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45366   void * jresult ;
45367   Dali::BufferImage result;
45368
45369   {
45370     try {
45371       result = Dali::BufferImage::WHITE();
45372     } catch (std::out_of_range& e) {
45373       {
45374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45375       };
45376     } catch (std::exception& e) {
45377       {
45378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45379       };
45380     } catch (Dali::DaliException e) {
45381       {
45382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45383       };
45384     } catch (...) {
45385       {
45386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45387       };
45388     }
45389   }
45390
45391   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45392   return jresult;
45393 }
45394
45395
45396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45397   void * jresult ;
45398   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45399   Dali::PixelBuffer *result = 0 ;
45400
45401   arg1 = (Dali::BufferImage *)jarg1;
45402   {
45403     try {
45404       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45405     } catch (std::out_of_range& e) {
45406       {
45407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45408       };
45409     } catch (std::exception& e) {
45410       {
45411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45412       };
45413     } catch (Dali::DaliException e) {
45414       {
45415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45416       };
45417     } catch (...) {
45418       {
45419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45420       };
45421     }
45422   }
45423
45424   jresult = (void *)result;
45425   return jresult;
45426 }
45427
45428
45429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45430   unsigned int jresult ;
45431   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45432   unsigned int result;
45433
45434   arg1 = (Dali::BufferImage *)jarg1;
45435   {
45436     try {
45437       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45438     } catch (std::out_of_range& e) {
45439       {
45440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (std::exception& e) {
45443       {
45444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45445       };
45446     } catch (Dali::DaliException e) {
45447       {
45448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45449       };
45450     } catch (...) {
45451       {
45452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45453       };
45454     }
45455   }
45456
45457   jresult = result;
45458   return jresult;
45459 }
45460
45461
45462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45463   unsigned int jresult ;
45464   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45465   unsigned int result;
45466
45467   arg1 = (Dali::BufferImage *)jarg1;
45468   {
45469     try {
45470       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45471     } catch (std::out_of_range& e) {
45472       {
45473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45474       };
45475     } catch (std::exception& e) {
45476       {
45477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45478       };
45479     } catch (Dali::DaliException e) {
45480       {
45481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45482       };
45483     } catch (...) {
45484       {
45485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45486       };
45487     }
45488   }
45489
45490   jresult = result;
45491   return jresult;
45492 }
45493
45494
45495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45496   int jresult ;
45497   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45498   Dali::Pixel::Format result;
45499
45500   arg1 = (Dali::BufferImage *)jarg1;
45501   {
45502     try {
45503       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45504     } catch (std::out_of_range& e) {
45505       {
45506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45507       };
45508     } catch (std::exception& e) {
45509       {
45510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45511       };
45512     } catch (Dali::DaliException e) {
45513       {
45514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45515       };
45516     } catch (...) {
45517       {
45518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45519       };
45520     }
45521   }
45522
45523   jresult = (int)result;
45524   return jresult;
45525 }
45526
45527
45528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45529   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45530
45531   arg1 = (Dali::BufferImage *)jarg1;
45532   {
45533     try {
45534       (arg1)->Update();
45535     } catch (std::out_of_range& e) {
45536       {
45537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45538       };
45539     } catch (std::exception& e) {
45540       {
45541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45542       };
45543     } catch (Dali::DaliException e) {
45544       {
45545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45546       };
45547     } catch (...) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45550       };
45551     }
45552   }
45553
45554 }
45555
45556
45557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45558   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45559   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45560   Dali::RectArea *argp2 ;
45561
45562   arg1 = (Dali::BufferImage *)jarg1;
45563   argp2 = (Dali::RectArea *)jarg2;
45564   if (!argp2) {
45565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45566     return ;
45567   }
45568   arg2 = *argp2;
45569   {
45570     try {
45571       (arg1)->Update(arg2);
45572     } catch (std::out_of_range& e) {
45573       {
45574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45575       };
45576     } catch (std::exception& e) {
45577       {
45578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45579       };
45580     } catch (Dali::DaliException e) {
45581       {
45582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45583       };
45584     } catch (...) {
45585       {
45586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45587       };
45588     }
45589   }
45590
45591 }
45592
45593
45594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45595   unsigned int jresult ;
45596   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45597   bool result;
45598
45599   arg1 = (Dali::BufferImage *)jarg1;
45600   {
45601     try {
45602       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45603     } catch (std::out_of_range& e) {
45604       {
45605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45606       };
45607     } catch (std::exception& e) {
45608       {
45609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45610       };
45611     } catch (Dali::DaliException e) {
45612       {
45613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45614       };
45615     } catch (...) {
45616       {
45617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45618       };
45619     }
45620   }
45621
45622   jresult = result;
45623   return jresult;
45624 }
45625
45626
45627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45628   void * jresult ;
45629   Dali::EncodedBufferImage *result = 0 ;
45630
45631   {
45632     try {
45633       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45634     } catch (std::out_of_range& e) {
45635       {
45636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45637       };
45638     } catch (std::exception& e) {
45639       {
45640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45641       };
45642     } catch (Dali::DaliException e) {
45643       {
45644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45645       };
45646     } catch (...) {
45647       {
45648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45649       };
45650     }
45651   }
45652
45653   jresult = (void *)result;
45654   return jresult;
45655 }
45656
45657
45658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45659   void * jresult ;
45660   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45661   std::size_t arg2 ;
45662   Dali::EncodedBufferImage result;
45663
45664   arg1 = (uint8_t *)jarg1;
45665   arg2 = (std::size_t)jarg2;
45666   {
45667     try {
45668       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45669     } catch (std::out_of_range& e) {
45670       {
45671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (std::exception& e) {
45674       {
45675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45676       };
45677     } catch (Dali::DaliException e) {
45678       {
45679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45680       };
45681     } catch (...) {
45682       {
45683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45684       };
45685     }
45686   }
45687
45688   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45689   return jresult;
45690 }
45691
45692
45693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45694   void * jresult ;
45695   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45696   std::size_t arg2 ;
45697   Dali::ImageDimensions arg3 ;
45698   Dali::FittingMode::Type arg4 ;
45699   Dali::SamplingMode::Type arg5 ;
45700   bool arg6 ;
45701   Dali::ImageDimensions *argp3 ;
45702   Dali::EncodedBufferImage result;
45703
45704   arg1 = (uint8_t *)jarg1;
45705   arg2 = (std::size_t)jarg2;
45706   argp3 = (Dali::ImageDimensions *)jarg3;
45707   if (!argp3) {
45708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45709     return 0;
45710   }
45711   arg3 = *argp3;
45712   arg4 = (Dali::FittingMode::Type)jarg4;
45713   arg5 = (Dali::SamplingMode::Type)jarg5;
45714   arg6 = jarg6 ? true : false;
45715   {
45716     try {
45717       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45718     } catch (std::out_of_range& e) {
45719       {
45720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45721       };
45722     } catch (std::exception& e) {
45723       {
45724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45725       };
45726     } catch (Dali::DaliException e) {
45727       {
45728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45729       };
45730     } catch (...) {
45731       {
45732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45733       };
45734     }
45735   }
45736
45737   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45738   return jresult;
45739 }
45740
45741
45742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45743   void * jresult ;
45744   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45745   std::size_t arg2 ;
45746   Dali::ImageDimensions arg3 ;
45747   Dali::FittingMode::Type arg4 ;
45748   Dali::SamplingMode::Type arg5 ;
45749   Dali::ImageDimensions *argp3 ;
45750   Dali::EncodedBufferImage result;
45751
45752   arg1 = (uint8_t *)jarg1;
45753   arg2 = (std::size_t)jarg2;
45754   argp3 = (Dali::ImageDimensions *)jarg3;
45755   if (!argp3) {
45756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45757     return 0;
45758   }
45759   arg3 = *argp3;
45760   arg4 = (Dali::FittingMode::Type)jarg4;
45761   arg5 = (Dali::SamplingMode::Type)jarg5;
45762   {
45763     try {
45764       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45765     } catch (std::out_of_range& e) {
45766       {
45767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (std::exception& e) {
45770       {
45771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45772       };
45773     } catch (Dali::DaliException e) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45776       };
45777     } catch (...) {
45778       {
45779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45780       };
45781     }
45782   }
45783
45784   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45785   return jresult;
45786 }
45787
45788
45789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45790   void * jresult ;
45791   Dali::BaseHandle arg1 ;
45792   Dali::BaseHandle *argp1 ;
45793   Dali::EncodedBufferImage result;
45794
45795   argp1 = (Dali::BaseHandle *)jarg1;
45796   if (!argp1) {
45797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45798     return 0;
45799   }
45800   arg1 = *argp1;
45801   {
45802     try {
45803       result = Dali::EncodedBufferImage::DownCast(arg1);
45804     } catch (std::out_of_range& e) {
45805       {
45806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (std::exception& e) {
45809       {
45810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45811       };
45812     } catch (Dali::DaliException e) {
45813       {
45814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45815       };
45816     } catch (...) {
45817       {
45818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45819       };
45820     }
45821   }
45822
45823   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45824   return jresult;
45825 }
45826
45827
45828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45829   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45830
45831   arg1 = (Dali::EncodedBufferImage *)jarg1;
45832   {
45833     try {
45834       delete arg1;
45835     } catch (std::out_of_range& e) {
45836       {
45837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45838       };
45839     } catch (std::exception& e) {
45840       {
45841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45842       };
45843     } catch (Dali::DaliException e) {
45844       {
45845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45846       };
45847     } catch (...) {
45848       {
45849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45850       };
45851     }
45852   }
45853
45854 }
45855
45856
45857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45858   void * jresult ;
45859   Dali::EncodedBufferImage *arg1 = 0 ;
45860   Dali::EncodedBufferImage *result = 0 ;
45861
45862   arg1 = (Dali::EncodedBufferImage *)jarg1;
45863   if (!arg1) {
45864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45865     return 0;
45866   }
45867   {
45868     try {
45869       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45870     } catch (std::out_of_range& e) {
45871       {
45872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45873       };
45874     } catch (std::exception& e) {
45875       {
45876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45877       };
45878     } catch (Dali::DaliException e) {
45879       {
45880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45881       };
45882     } catch (...) {
45883       {
45884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45885       };
45886     }
45887   }
45888
45889   jresult = (void *)result;
45890   return jresult;
45891 }
45892
45893
45894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45895   void * jresult ;
45896   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45897   Dali::EncodedBufferImage *arg2 = 0 ;
45898   Dali::EncodedBufferImage *result = 0 ;
45899
45900   arg1 = (Dali::EncodedBufferImage *)jarg1;
45901   arg2 = (Dali::EncodedBufferImage *)jarg2;
45902   if (!arg2) {
45903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45904     return 0;
45905   }
45906   {
45907     try {
45908       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45909     } catch (std::out_of_range& e) {
45910       {
45911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45912       };
45913     } catch (std::exception& e) {
45914       {
45915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45916       };
45917     } catch (Dali::DaliException e) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45920       };
45921     } catch (...) {
45922       {
45923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45924       };
45925     }
45926   }
45927
45928   jresult = (void *)result;
45929   return jresult;
45930 }
45931
45932
45933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45934   void * jresult ;
45935   Dali::NativeImage *result = 0 ;
45936
45937   {
45938     try {
45939       result = (Dali::NativeImage *)new Dali::NativeImage();
45940     } catch (std::out_of_range& e) {
45941       {
45942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45943       };
45944     } catch (std::exception& e) {
45945       {
45946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45947       };
45948     } catch (Dali::DaliException e) {
45949       {
45950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45951       };
45952     } catch (...) {
45953       {
45954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45955       };
45956     }
45957   }
45958
45959   jresult = (void *)result;
45960   return jresult;
45961 }
45962
45963
45964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45965   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45966
45967   arg1 = (Dali::NativeImage *)jarg1;
45968   {
45969     try {
45970       delete arg1;
45971     } catch (std::out_of_range& e) {
45972       {
45973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45974       };
45975     } catch (std::exception& e) {
45976       {
45977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45978       };
45979     } catch (Dali::DaliException e) {
45980       {
45981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45982       };
45983     } catch (...) {
45984       {
45985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45986       };
45987     }
45988   }
45989
45990 }
45991
45992
45993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45994   void * jresult ;
45995   Dali::NativeImage *arg1 = 0 ;
45996   Dali::NativeImage *result = 0 ;
45997
45998   arg1 = (Dali::NativeImage *)jarg1;
45999   if (!arg1) {
46000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46001     return 0;
46002   }
46003   {
46004     try {
46005       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46006     } catch (std::out_of_range& e) {
46007       {
46008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46009       };
46010     } catch (std::exception& e) {
46011       {
46012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46013       };
46014     } catch (Dali::DaliException e) {
46015       {
46016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46017       };
46018     } catch (...) {
46019       {
46020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46021       };
46022     }
46023   }
46024
46025   jresult = (void *)result;
46026   return jresult;
46027 }
46028
46029
46030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46031   void * jresult ;
46032   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46033   Dali::NativeImage *arg2 = 0 ;
46034   Dali::NativeImage *result = 0 ;
46035
46036   arg1 = (Dali::NativeImage *)jarg1;
46037   arg2 = (Dali::NativeImage *)jarg2;
46038   if (!arg2) {
46039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46040     return 0;
46041   }
46042   {
46043     try {
46044       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46045     } catch (std::out_of_range& e) {
46046       {
46047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46048       };
46049     } catch (std::exception& e) {
46050       {
46051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46052       };
46053     } catch (Dali::DaliException e) {
46054       {
46055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46056       };
46057     } catch (...) {
46058       {
46059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46060       };
46061     }
46062   }
46063
46064   jresult = (void *)result;
46065   return jresult;
46066 }
46067
46068
46069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46070   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46071
46072   arg1 = (Dali::NativeImage *)jarg1;
46073   {
46074     try {
46075       (arg1)->CreateGlTexture();
46076     } catch (std::out_of_range& e) {
46077       {
46078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46079       };
46080     } catch (std::exception& e) {
46081       {
46082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46083       };
46084     } catch (Dali::DaliException e) {
46085       {
46086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46087       };
46088     } catch (...) {
46089       {
46090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46091       };
46092     }
46093   }
46094
46095 }
46096
46097
46098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46099   void * jresult ;
46100   NativeImageInterface *arg1 = 0 ;
46101   Dali::NativeImage result;
46102
46103   arg1 = (NativeImageInterface *)jarg1;
46104   if (!arg1) {
46105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46106     return 0;
46107   }
46108   {
46109     try {
46110       result = Dali::NativeImage::New(*arg1);
46111     } catch (std::out_of_range& e) {
46112       {
46113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46114       };
46115     } catch (std::exception& e) {
46116       {
46117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46118       };
46119     } catch (Dali::DaliException e) {
46120       {
46121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46122       };
46123     } catch (...) {
46124       {
46125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46126       };
46127     }
46128   }
46129
46130   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46131   return jresult;
46132 }
46133
46134
46135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46136   void * jresult ;
46137   Dali::BaseHandle arg1 ;
46138   Dali::BaseHandle *argp1 ;
46139   Dali::NativeImage result;
46140
46141   argp1 = (Dali::BaseHandle *)jarg1;
46142   if (!argp1) {
46143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46144     return 0;
46145   }
46146   arg1 = *argp1;
46147   {
46148     try {
46149       result = Dali::NativeImage::DownCast(arg1);
46150     } catch (std::out_of_range& e) {
46151       {
46152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46153       };
46154     } catch (std::exception& e) {
46155       {
46156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46157       };
46158     } catch (Dali::DaliException e) {
46159       {
46160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46161       };
46162     } catch (...) {
46163       {
46164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46165       };
46166     }
46167   }
46168
46169   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46170   return jresult;
46171 }
46172
46173
46174 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46175   char * jresult ;
46176   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46177   char *result = 0 ;
46178
46179   arg1 = (Dali::NativeImage *)jarg1;
46180   {
46181     try {
46182       result = (char *)(arg1)->GetCustomFragmentPreFix();
46183     } catch (std::out_of_range& e) {
46184       {
46185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46186       };
46187     } catch (std::exception& e) {
46188       {
46189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46190       };
46191     } catch (Dali::DaliException e) {
46192       {
46193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46194       };
46195     } catch (...) {
46196       {
46197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46198       };
46199     }
46200   }
46201
46202   jresult = SWIG_csharp_string_callback((const char *)result);
46203   return jresult;
46204 }
46205
46206
46207 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46208   char * jresult ;
46209   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46210   char *result = 0 ;
46211
46212   arg1 = (Dali::NativeImage *)jarg1;
46213   {
46214     try {
46215       result = (char *)(arg1)->GetCustomSamplerTypename();
46216     } catch (std::out_of_range& e) {
46217       {
46218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46219       };
46220     } catch (std::exception& e) {
46221       {
46222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46223       };
46224     } catch (Dali::DaliException e) {
46225       {
46226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46227       };
46228     } catch (...) {
46229       {
46230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46231       };
46232     }
46233   }
46234
46235   jresult = SWIG_csharp_string_callback((const char *)result);
46236   return jresult;
46237 }
46238
46239
46240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46241   unsigned int jresult ;
46242   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46243   bool result;
46244
46245   arg1 = (Dali::NativeImageInterface *)jarg1;
46246   {
46247     try {
46248       result = (bool)(arg1)->GlExtensionCreate();
46249     } catch (std::out_of_range& e) {
46250       {
46251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46252       };
46253     } catch (std::exception& e) {
46254       {
46255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46256       };
46257     } catch (Dali::DaliException e) {
46258       {
46259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46260       };
46261     } catch (...) {
46262       {
46263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46264       };
46265     }
46266   }
46267
46268   jresult = result;
46269   return jresult;
46270 }
46271
46272
46273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46274   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46275
46276   arg1 = (Dali::NativeImageInterface *)jarg1;
46277   {
46278     try {
46279       (arg1)->GlExtensionDestroy();
46280     } catch (std::out_of_range& e) {
46281       {
46282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46283       };
46284     } catch (std::exception& e) {
46285       {
46286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46287       };
46288     } catch (Dali::DaliException e) {
46289       {
46290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46291       };
46292     } catch (...) {
46293       {
46294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46295       };
46296     }
46297   }
46298
46299 }
46300
46301
46302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46303   unsigned int jresult ;
46304   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46305   unsigned int result;
46306
46307   arg1 = (Dali::NativeImageInterface *)jarg1;
46308   {
46309     try {
46310       result = (unsigned int)(arg1)->TargetTexture();
46311     } catch (std::out_of_range& e) {
46312       {
46313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46314       };
46315     } catch (std::exception& e) {
46316       {
46317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46318       };
46319     } catch (Dali::DaliException e) {
46320       {
46321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46322       };
46323     } catch (...) {
46324       {
46325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46326       };
46327     }
46328   }
46329
46330   jresult = result;
46331   return jresult;
46332 }
46333
46334
46335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46336   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46337
46338   arg1 = (Dali::NativeImageInterface *)jarg1;
46339   {
46340     try {
46341       (arg1)->PrepareTexture();
46342     } catch (std::out_of_range& e) {
46343       {
46344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46345       };
46346     } catch (std::exception& e) {
46347       {
46348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46349       };
46350     } catch (Dali::DaliException e) {
46351       {
46352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46353       };
46354     } catch (...) {
46355       {
46356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46357       };
46358     }
46359   }
46360
46361 }
46362
46363
46364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46365   unsigned int jresult ;
46366   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46367   unsigned int result;
46368
46369   arg1 = (Dali::NativeImageInterface *)jarg1;
46370   {
46371     try {
46372       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46373     } catch (std::out_of_range& e) {
46374       {
46375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46376       };
46377     } catch (std::exception& e) {
46378       {
46379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46380       };
46381     } catch (Dali::DaliException e) {
46382       {
46383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46384       };
46385     } catch (...) {
46386       {
46387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46388       };
46389     }
46390   }
46391
46392   jresult = result;
46393   return jresult;
46394 }
46395
46396
46397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46398   unsigned int jresult ;
46399   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46400   unsigned int result;
46401
46402   arg1 = (Dali::NativeImageInterface *)jarg1;
46403   {
46404     try {
46405       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46406     } catch (std::out_of_range& e) {
46407       {
46408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46409       };
46410     } catch (std::exception& e) {
46411       {
46412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46413       };
46414     } catch (Dali::DaliException e) {
46415       {
46416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46417       };
46418     } catch (...) {
46419       {
46420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46421       };
46422     }
46423   }
46424
46425   jresult = result;
46426   return jresult;
46427 }
46428
46429
46430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46431   unsigned int jresult ;
46432   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46433   bool result;
46434
46435   arg1 = (Dali::NativeImageInterface *)jarg1;
46436   {
46437     try {
46438       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46439     } catch (std::out_of_range& e) {
46440       {
46441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46442       };
46443     } catch (std::exception& e) {
46444       {
46445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46446       };
46447     } catch (Dali::DaliException e) {
46448       {
46449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46450       };
46451     } catch (...) {
46452       {
46453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46454       };
46455     }
46456   }
46457
46458   jresult = result;
46459   return jresult;
46460 }
46461
46462
46463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46464   void * jresult ;
46465   std::string *arg1 = 0 ;
46466   Dali::ImageDimensions result;
46467
46468   if (!jarg1) {
46469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46470     return 0;
46471   }
46472   std::string arg1_str(jarg1);
46473   arg1 = &arg1_str;
46474   {
46475     try {
46476       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46477     } catch (std::out_of_range& e) {
46478       {
46479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46480       };
46481     } catch (std::exception& e) {
46482       {
46483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46484       };
46485     } catch (Dali::DaliException e) {
46486       {
46487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46488       };
46489     } catch (...) {
46490       {
46491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46492       };
46493     }
46494   }
46495
46496   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46497
46498   //argout typemap for const std::string&
46499
46500   return jresult;
46501 }
46502
46503
46504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46505   void * jresult ;
46506   Dali::ResourceImage *result = 0 ;
46507
46508   {
46509     try {
46510       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46511     } catch (std::out_of_range& e) {
46512       {
46513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46514       };
46515     } catch (std::exception& e) {
46516       {
46517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46518       };
46519     } catch (Dali::DaliException e) {
46520       {
46521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46522       };
46523     } catch (...) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46526       };
46527     }
46528   }
46529
46530   jresult = (void *)result;
46531   return jresult;
46532 }
46533
46534
46535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46536   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46537
46538   arg1 = (Dali::ResourceImage *)jarg1;
46539   {
46540     try {
46541       delete arg1;
46542     } catch (std::out_of_range& e) {
46543       {
46544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46545       };
46546     } catch (std::exception& e) {
46547       {
46548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46549       };
46550     } catch (Dali::DaliException e) {
46551       {
46552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46553       };
46554     } catch (...) {
46555       {
46556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46557       };
46558     }
46559   }
46560
46561 }
46562
46563
46564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46565   void * jresult ;
46566   Dali::ResourceImage *arg1 = 0 ;
46567   Dali::ResourceImage *result = 0 ;
46568
46569   arg1 = (Dali::ResourceImage *)jarg1;
46570   if (!arg1) {
46571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46572     return 0;
46573   }
46574   {
46575     try {
46576       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46577     } catch (std::out_of_range& e) {
46578       {
46579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46580       };
46581     } catch (std::exception& e) {
46582       {
46583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46584       };
46585     } catch (Dali::DaliException e) {
46586       {
46587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46588       };
46589     } catch (...) {
46590       {
46591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46592       };
46593     }
46594   }
46595
46596   jresult = (void *)result;
46597   return jresult;
46598 }
46599
46600
46601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46602   void * jresult ;
46603   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46604   Dali::ResourceImage *arg2 = 0 ;
46605   Dali::ResourceImage *result = 0 ;
46606
46607   arg1 = (Dali::ResourceImage *)jarg1;
46608   arg2 = (Dali::ResourceImage *)jarg2;
46609   if (!arg2) {
46610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46611     return 0;
46612   }
46613   {
46614     try {
46615       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46616     } catch (std::out_of_range& e) {
46617       {
46618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46619       };
46620     } catch (std::exception& e) {
46621       {
46622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46623       };
46624     } catch (Dali::DaliException e) {
46625       {
46626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46627       };
46628     } catch (...) {
46629       {
46630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46631       };
46632     }
46633   }
46634
46635   jresult = (void *)result;
46636   return jresult;
46637 }
46638
46639
46640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46641   void * jresult ;
46642   std::string *arg1 = 0 ;
46643   bool arg2 ;
46644   Dali::ResourceImage result;
46645
46646   if (!jarg1) {
46647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46648     return 0;
46649   }
46650   std::string arg1_str(jarg1);
46651   arg1 = &arg1_str;
46652   arg2 = jarg2 ? true : false;
46653   {
46654     try {
46655       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46656     } catch (std::out_of_range& e) {
46657       {
46658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46659       };
46660     } catch (std::exception& e) {
46661       {
46662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46663       };
46664     } catch (Dali::DaliException e) {
46665       {
46666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46667       };
46668     } catch (...) {
46669       {
46670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46671       };
46672     }
46673   }
46674
46675   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46676
46677   //argout typemap for const std::string&
46678
46679   return jresult;
46680 }
46681
46682
46683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46684   void * jresult ;
46685   std::string *arg1 = 0 ;
46686   Dali::ResourceImage result;
46687
46688   if (!jarg1) {
46689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46690     return 0;
46691   }
46692   std::string arg1_str(jarg1);
46693   arg1 = &arg1_str;
46694   {
46695     try {
46696       result = Dali::ResourceImage::New((std::string const &)*arg1);
46697     } catch (std::out_of_range& e) {
46698       {
46699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46700       };
46701     } catch (std::exception& e) {
46702       {
46703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46704       };
46705     } catch (Dali::DaliException e) {
46706       {
46707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46708       };
46709     } catch (...) {
46710       {
46711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46712       };
46713     }
46714   }
46715
46716   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46717
46718   //argout typemap for const std::string&
46719
46720   return jresult;
46721 }
46722
46723
46724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46725   void * jresult ;
46726   std::string *arg1 = 0 ;
46727   Dali::ImageDimensions arg2 ;
46728   Dali::FittingMode::Type arg3 ;
46729   Dali::SamplingMode::Type arg4 ;
46730   bool arg5 ;
46731   Dali::ImageDimensions *argp2 ;
46732   Dali::ResourceImage result;
46733
46734   if (!jarg1) {
46735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46736     return 0;
46737   }
46738   std::string arg1_str(jarg1);
46739   arg1 = &arg1_str;
46740   argp2 = (Dali::ImageDimensions *)jarg2;
46741   if (!argp2) {
46742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46743     return 0;
46744   }
46745   arg2 = *argp2;
46746   arg3 = (Dali::FittingMode::Type)jarg3;
46747   arg4 = (Dali::SamplingMode::Type)jarg4;
46748   arg5 = jarg5 ? true : false;
46749   {
46750     try {
46751       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46752     } catch (std::out_of_range& e) {
46753       {
46754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46755       };
46756     } catch (std::exception& e) {
46757       {
46758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46759       };
46760     } catch (Dali::DaliException e) {
46761       {
46762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46763       };
46764     } catch (...) {
46765       {
46766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46767       };
46768     }
46769   }
46770
46771   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46772
46773   //argout typemap for const std::string&
46774
46775   return jresult;
46776 }
46777
46778
46779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46780   void * jresult ;
46781   std::string *arg1 = 0 ;
46782   Dali::ImageDimensions arg2 ;
46783   Dali::FittingMode::Type arg3 ;
46784   Dali::SamplingMode::Type arg4 ;
46785   Dali::ImageDimensions *argp2 ;
46786   Dali::ResourceImage result;
46787
46788   if (!jarg1) {
46789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46790     return 0;
46791   }
46792   std::string arg1_str(jarg1);
46793   arg1 = &arg1_str;
46794   argp2 = (Dali::ImageDimensions *)jarg2;
46795   if (!argp2) {
46796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46797     return 0;
46798   }
46799   arg2 = *argp2;
46800   arg3 = (Dali::FittingMode::Type)jarg3;
46801   arg4 = (Dali::SamplingMode::Type)jarg4;
46802   {
46803     try {
46804       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46805     } catch (std::out_of_range& e) {
46806       {
46807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46808       };
46809     } catch (std::exception& e) {
46810       {
46811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46812       };
46813     } catch (Dali::DaliException e) {
46814       {
46815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46816       };
46817     } catch (...) {
46818       {
46819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46820       };
46821     }
46822   }
46823
46824   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46825
46826   //argout typemap for const std::string&
46827
46828   return jresult;
46829 }
46830
46831
46832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46833   void * jresult ;
46834   std::string *arg1 = 0 ;
46835   Dali::ImageDimensions arg2 ;
46836   Dali::FittingMode::Type arg3 ;
46837   Dali::ImageDimensions *argp2 ;
46838   Dali::ResourceImage result;
46839
46840   if (!jarg1) {
46841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46842     return 0;
46843   }
46844   std::string arg1_str(jarg1);
46845   arg1 = &arg1_str;
46846   argp2 = (Dali::ImageDimensions *)jarg2;
46847   if (!argp2) {
46848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46849     return 0;
46850   }
46851   arg2 = *argp2;
46852   arg3 = (Dali::FittingMode::Type)jarg3;
46853   {
46854     try {
46855       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46856     } catch (std::out_of_range& e) {
46857       {
46858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46859       };
46860     } catch (std::exception& e) {
46861       {
46862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46863       };
46864     } catch (Dali::DaliException e) {
46865       {
46866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46867       };
46868     } catch (...) {
46869       {
46870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46871       };
46872     }
46873   }
46874
46875   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46876
46877   //argout typemap for const std::string&
46878
46879   return jresult;
46880 }
46881
46882
46883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46884   void * jresult ;
46885   std::string *arg1 = 0 ;
46886   Dali::ImageDimensions arg2 ;
46887   Dali::ImageDimensions *argp2 ;
46888   Dali::ResourceImage result;
46889
46890   if (!jarg1) {
46891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46892     return 0;
46893   }
46894   std::string arg1_str(jarg1);
46895   arg1 = &arg1_str;
46896   argp2 = (Dali::ImageDimensions *)jarg2;
46897   if (!argp2) {
46898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46899     return 0;
46900   }
46901   arg2 = *argp2;
46902   {
46903     try {
46904       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46905     } catch (std::out_of_range& e) {
46906       {
46907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46908       };
46909     } catch (std::exception& e) {
46910       {
46911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46912       };
46913     } catch (Dali::DaliException e) {
46914       {
46915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46916       };
46917     } catch (...) {
46918       {
46919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46920       };
46921     }
46922   }
46923
46924   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46925
46926   //argout typemap for const std::string&
46927
46928   return jresult;
46929 }
46930
46931
46932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46933   void * jresult ;
46934   Dali::BaseHandle arg1 ;
46935   Dali::BaseHandle *argp1 ;
46936   Dali::ResourceImage result;
46937
46938   argp1 = (Dali::BaseHandle *)jarg1;
46939   if (!argp1) {
46940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46941     return 0;
46942   }
46943   arg1 = *argp1;
46944   {
46945     try {
46946       result = Dali::ResourceImage::DownCast(arg1);
46947     } catch (std::out_of_range& e) {
46948       {
46949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46950       };
46951     } catch (std::exception& e) {
46952       {
46953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46954       };
46955     } catch (Dali::DaliException e) {
46956       {
46957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46958       };
46959     } catch (...) {
46960       {
46961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46962       };
46963     }
46964   }
46965
46966   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46972   int jresult ;
46973   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46974   Dali::LoadingState result;
46975
46976   arg1 = (Dali::ResourceImage *)jarg1;
46977   {
46978     try {
46979       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46980     } catch (std::out_of_range& e) {
46981       {
46982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46983       };
46984     } catch (std::exception& e) {
46985       {
46986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46987       };
46988     } catch (Dali::DaliException e) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46991       };
46992     } catch (...) {
46993       {
46994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46995       };
46996     }
46997   }
46998
46999   jresult = (int)result;
47000   return jresult;
47001 }
47002
47003
47004 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47005   char * jresult ;
47006   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47007   std::string result;
47008
47009   arg1 = (Dali::ResourceImage *)jarg1;
47010   {
47011     try {
47012       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47013     } catch (std::out_of_range& e) {
47014       {
47015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47016       };
47017     } catch (std::exception& e) {
47018       {
47019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47020       };
47021     } catch (Dali::DaliException e) {
47022       {
47023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47024       };
47025     } catch (...) {
47026       {
47027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47028       };
47029     }
47030   }
47031
47032   jresult = SWIG_csharp_string_callback((&result)->c_str());
47033   return jresult;
47034 }
47035
47036
47037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47038   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47039
47040   arg1 = (Dali::ResourceImage *)jarg1;
47041   {
47042     try {
47043       (arg1)->Reload();
47044     } catch (std::out_of_range& e) {
47045       {
47046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47047       };
47048     } catch (std::exception& e) {
47049       {
47050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47051       };
47052     } catch (Dali::DaliException e) {
47053       {
47054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47055       };
47056     } catch (...) {
47057       {
47058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47059       };
47060     }
47061   }
47062
47063 }
47064
47065
47066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47067   void * jresult ;
47068   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47069   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47070
47071   arg1 = (Dali::ResourceImage *)jarg1;
47072   {
47073     try {
47074       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47075     } catch (std::out_of_range& e) {
47076       {
47077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (std::exception& e) {
47080       {
47081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47082       };
47083     } catch (Dali::DaliException e) {
47084       {
47085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47086       };
47087     } catch (...) {
47088       {
47089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47090       };
47091     }
47092   }
47093
47094   jresult = (void *)result;
47095   return jresult;
47096 }
47097
47098
47099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47100   void * jresult ;
47101   Dali::FrameBufferImage *result = 0 ;
47102
47103   {
47104     try {
47105       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47106     } catch (std::out_of_range& e) {
47107       {
47108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47109       };
47110     } catch (std::exception& e) {
47111       {
47112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47113       };
47114     } catch (Dali::DaliException e) {
47115       {
47116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47117       };
47118     } catch (...) {
47119       {
47120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47121       };
47122     }
47123   }
47124
47125   jresult = (void *)result;
47126   return jresult;
47127 }
47128
47129
47130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47131   void * jresult ;
47132   unsigned int arg1 ;
47133   unsigned int arg2 ;
47134   Dali::Pixel::Format arg3 ;
47135   Dali::RenderBuffer::Format arg4 ;
47136   Dali::FrameBufferImage result;
47137
47138   arg1 = (unsigned int)jarg1;
47139   arg2 = (unsigned int)jarg2;
47140   arg3 = (Dali::Pixel::Format)jarg3;
47141   arg4 = (Dali::RenderBuffer::Format)jarg4;
47142   {
47143     try {
47144       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47145     } catch (std::out_of_range& e) {
47146       {
47147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (std::exception& e) {
47150       {
47151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47152       };
47153     } catch (Dali::DaliException e) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47156       };
47157     } catch (...) {
47158       {
47159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47160       };
47161     }
47162   }
47163
47164   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47165   return jresult;
47166 }
47167
47168
47169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47170   void * jresult ;
47171   unsigned int arg1 ;
47172   unsigned int arg2 ;
47173   Dali::Pixel::Format arg3 ;
47174   Dali::FrameBufferImage result;
47175
47176   arg1 = (unsigned int)jarg1;
47177   arg2 = (unsigned int)jarg2;
47178   arg3 = (Dali::Pixel::Format)jarg3;
47179   {
47180     try {
47181       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47182     } catch (std::out_of_range& e) {
47183       {
47184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47185       };
47186     } catch (std::exception& e) {
47187       {
47188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47189       };
47190     } catch (Dali::DaliException e) {
47191       {
47192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47193       };
47194     } catch (...) {
47195       {
47196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47197       };
47198     }
47199   }
47200
47201   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47202   return jresult;
47203 }
47204
47205
47206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47207   void * jresult ;
47208   unsigned int arg1 ;
47209   unsigned int arg2 ;
47210   Dali::FrameBufferImage result;
47211
47212   arg1 = (unsigned int)jarg1;
47213   arg2 = (unsigned int)jarg2;
47214   {
47215     try {
47216       result = Dali::FrameBufferImage::New(arg1,arg2);
47217     } catch (std::out_of_range& e) {
47218       {
47219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47220       };
47221     } catch (std::exception& e) {
47222       {
47223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47224       };
47225     } catch (Dali::DaliException e) {
47226       {
47227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47228       };
47229     } catch (...) {
47230       {
47231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47232       };
47233     }
47234   }
47235
47236   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47237   return jresult;
47238 }
47239
47240
47241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47242   void * jresult ;
47243   unsigned int arg1 ;
47244   Dali::FrameBufferImage result;
47245
47246   arg1 = (unsigned int)jarg1;
47247   {
47248     try {
47249       result = Dali::FrameBufferImage::New(arg1);
47250     } catch (std::out_of_range& e) {
47251       {
47252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47253       };
47254     } catch (std::exception& e) {
47255       {
47256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47257       };
47258     } catch (Dali::DaliException e) {
47259       {
47260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47261       };
47262     } catch (...) {
47263       {
47264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47265       };
47266     }
47267   }
47268
47269   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47270   return jresult;
47271 }
47272
47273
47274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47275   void * jresult ;
47276   Dali::FrameBufferImage result;
47277
47278   {
47279     try {
47280       result = Dali::FrameBufferImage::New();
47281     } catch (std::out_of_range& e) {
47282       {
47283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47284       };
47285     } catch (std::exception& e) {
47286       {
47287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47288       };
47289     } catch (Dali::DaliException e) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47292       };
47293     } catch (...) {
47294       {
47295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47296       };
47297     }
47298   }
47299
47300   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47301   return jresult;
47302 }
47303
47304
47305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47306   void * jresult ;
47307   Dali::NativeImageInterface *arg1 = 0 ;
47308   Dali::FrameBufferImage result;
47309
47310   arg1 = (Dali::NativeImageInterface *)jarg1;
47311   if (!arg1) {
47312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47313     return 0;
47314   }
47315   {
47316     try {
47317       result = Dali::FrameBufferImage::New(*arg1);
47318     } catch (std::out_of_range& e) {
47319       {
47320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47321       };
47322     } catch (std::exception& e) {
47323       {
47324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (Dali::DaliException e) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47329       };
47330     } catch (...) {
47331       {
47332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47333       };
47334     }
47335   }
47336
47337   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47338   return jresult;
47339 }
47340
47341
47342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47343   void * jresult ;
47344   Dali::BaseHandle arg1 ;
47345   Dali::BaseHandle *argp1 ;
47346   Dali::FrameBufferImage result;
47347
47348   argp1 = (Dali::BaseHandle *)jarg1;
47349   if (!argp1) {
47350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47351     return 0;
47352   }
47353   arg1 = *argp1;
47354   {
47355     try {
47356       result = Dali::FrameBufferImage::DownCast(arg1);
47357     } catch (std::out_of_range& e) {
47358       {
47359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47360       };
47361     } catch (std::exception& e) {
47362       {
47363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47364       };
47365     } catch (Dali::DaliException e) {
47366       {
47367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47368       };
47369     } catch (...) {
47370       {
47371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47372       };
47373     }
47374   }
47375
47376   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47377   return jresult;
47378 }
47379
47380
47381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47382   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47383
47384   arg1 = (Dali::FrameBufferImage *)jarg1;
47385   {
47386     try {
47387       delete arg1;
47388     } catch (std::out_of_range& e) {
47389       {
47390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47391       };
47392     } catch (std::exception& e) {
47393       {
47394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47395       };
47396     } catch (Dali::DaliException e) {
47397       {
47398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47399       };
47400     } catch (...) {
47401       {
47402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47403       };
47404     }
47405   }
47406
47407 }
47408
47409
47410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47411   void * jresult ;
47412   Dali::FrameBufferImage *arg1 = 0 ;
47413   Dali::FrameBufferImage *result = 0 ;
47414
47415   arg1 = (Dali::FrameBufferImage *)jarg1;
47416   if (!arg1) {
47417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47418     return 0;
47419   }
47420   {
47421     try {
47422       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47423     } catch (std::out_of_range& e) {
47424       {
47425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47426       };
47427     } catch (std::exception& e) {
47428       {
47429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47430       };
47431     } catch (Dali::DaliException e) {
47432       {
47433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47434       };
47435     } catch (...) {
47436       {
47437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47438       };
47439     }
47440   }
47441
47442   jresult = (void *)result;
47443   return jresult;
47444 }
47445
47446
47447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47448   void * jresult ;
47449   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47450   Dali::FrameBufferImage *arg2 = 0 ;
47451   Dali::FrameBufferImage *result = 0 ;
47452
47453   arg1 = (Dali::FrameBufferImage *)jarg1;
47454   arg2 = (Dali::FrameBufferImage *)jarg2;
47455   if (!arg2) {
47456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47457     return 0;
47458   }
47459   {
47460     try {
47461       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47462     } catch (std::out_of_range& e) {
47463       {
47464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47465       };
47466     } catch (std::exception& e) {
47467       {
47468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47469       };
47470     } catch (Dali::DaliException e) {
47471       {
47472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47473       };
47474     } catch (...) {
47475       {
47476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47477       };
47478     }
47479   }
47480
47481   jresult = (void *)result;
47482   return jresult;
47483 }
47484
47485
47486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47487   void * jresult ;
47488   Dali::NinePatchImage *result = 0 ;
47489
47490   {
47491     try {
47492       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47493     } catch (std::out_of_range& e) {
47494       {
47495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47496       };
47497     } catch (std::exception& e) {
47498       {
47499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47500       };
47501     } catch (Dali::DaliException e) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47504       };
47505     } catch (...) {
47506       {
47507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47508       };
47509     }
47510   }
47511
47512   jresult = (void *)result;
47513   return jresult;
47514 }
47515
47516
47517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47518   void * jresult ;
47519   std::string *arg1 = 0 ;
47520   Dali::NinePatchImage result;
47521
47522   if (!jarg1) {
47523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47524     return 0;
47525   }
47526   std::string arg1_str(jarg1);
47527   arg1 = &arg1_str;
47528   {
47529     try {
47530       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47531     } catch (std::out_of_range& e) {
47532       {
47533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47534       };
47535     } catch (std::exception& e) {
47536       {
47537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47538       };
47539     } catch (Dali::DaliException e) {
47540       {
47541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47542       };
47543     } catch (...) {
47544       {
47545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47546       };
47547     }
47548   }
47549
47550   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47551
47552   //argout typemap for const std::string&
47553
47554   return jresult;
47555 }
47556
47557
47558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47559   void * jresult ;
47560   Dali::BaseHandle arg1 ;
47561   Dali::BaseHandle *argp1 ;
47562   Dali::NinePatchImage result;
47563
47564   argp1 = (Dali::BaseHandle *)jarg1;
47565   if (!argp1) {
47566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47567     return 0;
47568   }
47569   arg1 = *argp1;
47570   {
47571     try {
47572       result = Dali::NinePatchImage::DownCast(arg1);
47573     } catch (std::out_of_range& e) {
47574       {
47575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47576       };
47577     } catch (std::exception& e) {
47578       {
47579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47580       };
47581     } catch (Dali::DaliException e) {
47582       {
47583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47584       };
47585     } catch (...) {
47586       {
47587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47588       };
47589     }
47590   }
47591
47592   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47593   return jresult;
47594 }
47595
47596
47597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47598   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47599
47600   arg1 = (Dali::NinePatchImage *)jarg1;
47601   {
47602     try {
47603       delete arg1;
47604     } catch (std::out_of_range& e) {
47605       {
47606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47607       };
47608     } catch (std::exception& e) {
47609       {
47610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47611       };
47612     } catch (Dali::DaliException e) {
47613       {
47614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47615       };
47616     } catch (...) {
47617       {
47618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47619       };
47620     }
47621   }
47622
47623 }
47624
47625
47626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47627   void * jresult ;
47628   Dali::NinePatchImage *arg1 = 0 ;
47629   Dali::NinePatchImage *result = 0 ;
47630
47631   arg1 = (Dali::NinePatchImage *)jarg1;
47632   if (!arg1) {
47633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47634     return 0;
47635   }
47636   {
47637     try {
47638       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47639     } catch (std::out_of_range& e) {
47640       {
47641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47642       };
47643     } catch (std::exception& e) {
47644       {
47645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47646       };
47647     } catch (Dali::DaliException e) {
47648       {
47649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47650       };
47651     } catch (...) {
47652       {
47653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47654       };
47655     }
47656   }
47657
47658   jresult = (void *)result;
47659   return jresult;
47660 }
47661
47662
47663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47664   void * jresult ;
47665   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47666   Dali::NinePatchImage *arg2 = 0 ;
47667   Dali::NinePatchImage *result = 0 ;
47668
47669   arg1 = (Dali::NinePatchImage *)jarg1;
47670   arg2 = (Dali::NinePatchImage *)jarg2;
47671   if (!arg2) {
47672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47673     return 0;
47674   }
47675   {
47676     try {
47677       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47678     } catch (std::out_of_range& e) {
47679       {
47680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47681       };
47682     } catch (std::exception& e) {
47683       {
47684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47685       };
47686     } catch (Dali::DaliException e) {
47687       {
47688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47689       };
47690     } catch (...) {
47691       {
47692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47693       };
47694     }
47695   }
47696
47697   jresult = (void *)result;
47698   return jresult;
47699 }
47700
47701
47702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47703   void * jresult ;
47704   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47705   Dali::Vector4 result;
47706
47707   arg1 = (Dali::NinePatchImage *)jarg1;
47708   {
47709     try {
47710       result = (arg1)->GetStretchBorders();
47711     } catch (std::out_of_range& e) {
47712       {
47713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47714       };
47715     } catch (std::exception& e) {
47716       {
47717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47718       };
47719     } catch (Dali::DaliException e) {
47720       {
47721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47722       };
47723     } catch (...) {
47724       {
47725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47726       };
47727     }
47728   }
47729
47730   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47731   return jresult;
47732 }
47733
47734
47735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47736   void * jresult ;
47737   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47738   Dali::NinePatchImage::StretchRanges *result = 0 ;
47739
47740   arg1 = (Dali::NinePatchImage *)jarg1;
47741   {
47742     try {
47743       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47744     } catch (std::out_of_range& e) {
47745       {
47746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (std::exception& e) {
47749       {
47750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47751       };
47752     } catch (Dali::DaliException e) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47755       };
47756     } catch (...) {
47757       {
47758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47759       };
47760     }
47761   }
47762
47763   jresult = (void *)result;
47764   return jresult;
47765 }
47766
47767
47768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47769   void * jresult ;
47770   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47771   Dali::NinePatchImage::StretchRanges *result = 0 ;
47772
47773   arg1 = (Dali::NinePatchImage *)jarg1;
47774   {
47775     try {
47776       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47777     } catch (std::out_of_range& e) {
47778       {
47779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (std::exception& e) {
47782       {
47783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47784       };
47785     } catch (Dali::DaliException e) {
47786       {
47787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47788       };
47789     } catch (...) {
47790       {
47791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47792       };
47793     }
47794   }
47795
47796   jresult = (void *)result;
47797   return jresult;
47798 }
47799
47800
47801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47802   void * jresult ;
47803   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47804   Dali::Rect< int > result;
47805
47806   arg1 = (Dali::NinePatchImage *)jarg1;
47807   {
47808     try {
47809       result = (arg1)->GetChildRectangle();
47810     } catch (std::out_of_range& e) {
47811       {
47812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47813       };
47814     } catch (std::exception& e) {
47815       {
47816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47817       };
47818     } catch (Dali::DaliException e) {
47819       {
47820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47821       };
47822     } catch (...) {
47823       {
47824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47825       };
47826     }
47827   }
47828
47829   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47830   return jresult;
47831 }
47832
47833
47834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47835   void * jresult ;
47836   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47837   Dali::BufferImage result;
47838
47839   arg1 = (Dali::NinePatchImage *)jarg1;
47840   {
47841     try {
47842       result = (arg1)->CreateCroppedBufferImage();
47843     } catch (std::out_of_range& e) {
47844       {
47845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (std::exception& e) {
47848       {
47849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47850       };
47851     } catch (Dali::DaliException e) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47854       };
47855     } catch (...) {
47856       {
47857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47858       };
47859     }
47860   }
47861
47862   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47863   return jresult;
47864 }
47865
47866
47867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47868   unsigned int jresult ;
47869   std::string *arg1 = 0 ;
47870   bool result;
47871
47872   if (!jarg1) {
47873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47874     return 0;
47875   }
47876   std::string arg1_str(jarg1);
47877   arg1 = &arg1_str;
47878   {
47879     try {
47880       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47881     } catch (std::out_of_range& e) {
47882       {
47883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47884       };
47885     } catch (std::exception& e) {
47886       {
47887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47888       };
47889     } catch (Dali::DaliException e) {
47890       {
47891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47892       };
47893     } catch (...) {
47894       {
47895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47896       };
47897     }
47898   }
47899
47900   jresult = result;
47901
47902   //argout typemap for const std::string&
47903
47904   return jresult;
47905 }
47906
47907
47908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47909   int jresult ;
47910   int result;
47911
47912   result = (int)Dali::CameraActor::Property::TYPE;
47913   jresult = (int)result;
47914   return jresult;
47915 }
47916
47917
47918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47919   int jresult ;
47920   int result;
47921
47922   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47923   jresult = (int)result;
47924   return jresult;
47925 }
47926
47927
47928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47929   int jresult ;
47930   int result;
47931
47932   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47933   jresult = (int)result;
47934   return jresult;
47935 }
47936
47937
47938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47939   int jresult ;
47940   int result;
47941
47942   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47943   jresult = (int)result;
47944   return jresult;
47945 }
47946
47947
47948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47949   int jresult ;
47950   int result;
47951
47952   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47953   jresult = (int)result;
47954   return jresult;
47955 }
47956
47957
47958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47959   int jresult ;
47960   int result;
47961
47962   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47963   jresult = (int)result;
47964   return jresult;
47965 }
47966
47967
47968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47969   int jresult ;
47970   int result;
47971
47972   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47973   jresult = (int)result;
47974   return jresult;
47975 }
47976
47977
47978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47979   int jresult ;
47980   int result;
47981
47982   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47983   jresult = (int)result;
47984   return jresult;
47985 }
47986
47987
47988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47989   int jresult ;
47990   int result;
47991
47992   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47993   jresult = (int)result;
47994   return jresult;
47995 }
47996
47997
47998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47999   int jresult ;
48000   int result;
48001
48002   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48003   jresult = (int)result;
48004   return jresult;
48005 }
48006
48007
48008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48009   int jresult ;
48010   int result;
48011
48012   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48013   jresult = (int)result;
48014   return jresult;
48015 }
48016
48017
48018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48019   int jresult ;
48020   int result;
48021
48022   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48023   jresult = (int)result;
48024   return jresult;
48025 }
48026
48027
48028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48029   int jresult ;
48030   int result;
48031
48032   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48033   jresult = (int)result;
48034   return jresult;
48035 }
48036
48037
48038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48039   int jresult ;
48040   int result;
48041
48042   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48043   jresult = (int)result;
48044   return jresult;
48045 }
48046
48047
48048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48049   void * jresult ;
48050   Dali::CameraActor::Property *result = 0 ;
48051
48052   {
48053     try {
48054       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48055     } catch (std::out_of_range& e) {
48056       {
48057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48058       };
48059     } catch (std::exception& e) {
48060       {
48061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48062       };
48063     } catch (Dali::DaliException e) {
48064       {
48065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48066       };
48067     } catch (...) {
48068       {
48069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48070       };
48071     }
48072   }
48073
48074   jresult = (void *)result;
48075   return jresult;
48076 }
48077
48078
48079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48080   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48081
48082   arg1 = (Dali::CameraActor::Property *)jarg1;
48083   {
48084     try {
48085       delete arg1;
48086     } catch (std::out_of_range& e) {
48087       {
48088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48089       };
48090     } catch (std::exception& e) {
48091       {
48092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48093       };
48094     } catch (Dali::DaliException e) {
48095       {
48096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48097       };
48098     } catch (...) {
48099       {
48100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48101       };
48102     }
48103   }
48104
48105 }
48106
48107
48108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48109   void * jresult ;
48110   Dali::CameraActor *result = 0 ;
48111
48112   {
48113     try {
48114       result = (Dali::CameraActor *)new Dali::CameraActor();
48115     } catch (std::out_of_range& e) {
48116       {
48117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48118       };
48119     } catch (std::exception& e) {
48120       {
48121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48122       };
48123     } catch (Dali::DaliException e) {
48124       {
48125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48126       };
48127     } catch (...) {
48128       {
48129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48130       };
48131     }
48132   }
48133
48134   jresult = (void *)result;
48135   return jresult;
48136 }
48137
48138
48139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48140   void * jresult ;
48141   Dali::CameraActor result;
48142
48143   {
48144     try {
48145       result = Dali::CameraActor::New();
48146     } catch (std::out_of_range& e) {
48147       {
48148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48149       };
48150     } catch (std::exception& e) {
48151       {
48152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48153       };
48154     } catch (Dali::DaliException e) {
48155       {
48156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48157       };
48158     } catch (...) {
48159       {
48160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48161       };
48162     }
48163   }
48164
48165   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48166   return jresult;
48167 }
48168
48169
48170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48171   void * jresult ;
48172   Dali::Size *arg1 = 0 ;
48173   Dali::CameraActor result;
48174
48175   arg1 = (Dali::Size *)jarg1;
48176   if (!arg1) {
48177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48178     return 0;
48179   }
48180   {
48181     try {
48182       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48183     } catch (std::out_of_range& e) {
48184       {
48185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48186       };
48187     } catch (std::exception& e) {
48188       {
48189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48190       };
48191     } catch (Dali::DaliException e) {
48192       {
48193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48194       };
48195     } catch (...) {
48196       {
48197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48198       };
48199     }
48200   }
48201
48202   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48203   return jresult;
48204 }
48205
48206
48207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48208   void * jresult ;
48209   Dali::BaseHandle arg1 ;
48210   Dali::BaseHandle *argp1 ;
48211   Dali::CameraActor result;
48212
48213   argp1 = (Dali::BaseHandle *)jarg1;
48214   if (!argp1) {
48215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48216     return 0;
48217   }
48218   arg1 = *argp1;
48219   {
48220     try {
48221       result = Dali::CameraActor::DownCast(arg1);
48222     } catch (std::out_of_range& e) {
48223       {
48224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (std::exception& e) {
48227       {
48228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48229       };
48230     } catch (Dali::DaliException e) {
48231       {
48232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48233       };
48234     } catch (...) {
48235       {
48236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48237       };
48238     }
48239   }
48240
48241   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48242   return jresult;
48243 }
48244
48245
48246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48247   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48248
48249   arg1 = (Dali::CameraActor *)jarg1;
48250   {
48251     try {
48252       delete arg1;
48253     } catch (std::out_of_range& e) {
48254       {
48255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48256       };
48257     } catch (std::exception& e) {
48258       {
48259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48260       };
48261     } catch (Dali::DaliException e) {
48262       {
48263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48264       };
48265     } catch (...) {
48266       {
48267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48268       };
48269     }
48270   }
48271
48272 }
48273
48274
48275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48276   void * jresult ;
48277   Dali::CameraActor *arg1 = 0 ;
48278   Dali::CameraActor *result = 0 ;
48279
48280   arg1 = (Dali::CameraActor *)jarg1;
48281   if (!arg1) {
48282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48283     return 0;
48284   }
48285   {
48286     try {
48287       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48288     } catch (std::out_of_range& e) {
48289       {
48290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48291       };
48292     } catch (std::exception& e) {
48293       {
48294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48295       };
48296     } catch (Dali::DaliException e) {
48297       {
48298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48299       };
48300     } catch (...) {
48301       {
48302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48303       };
48304     }
48305   }
48306
48307   jresult = (void *)result;
48308   return jresult;
48309 }
48310
48311
48312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48313   void * jresult ;
48314   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48315   Dali::CameraActor *arg2 = 0 ;
48316   Dali::CameraActor *result = 0 ;
48317
48318   arg1 = (Dali::CameraActor *)jarg1;
48319   arg2 = (Dali::CameraActor *)jarg2;
48320   if (!arg2) {
48321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48322     return 0;
48323   }
48324   {
48325     try {
48326       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48327     } catch (std::out_of_range& e) {
48328       {
48329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48330       };
48331     } catch (std::exception& e) {
48332       {
48333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48334       };
48335     } catch (Dali::DaliException e) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48338       };
48339     } catch (...) {
48340       {
48341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48342       };
48343     }
48344   }
48345
48346   jresult = (void *)result;
48347   return jresult;
48348 }
48349
48350
48351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48352   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48353   Dali::Camera::Type arg2 ;
48354
48355   arg1 = (Dali::CameraActor *)jarg1;
48356   arg2 = (Dali::Camera::Type)jarg2;
48357   {
48358     try {
48359       (arg1)->SetType(arg2);
48360     } catch (std::out_of_range& e) {
48361       {
48362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48363       };
48364     } catch (std::exception& e) {
48365       {
48366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48367       };
48368     } catch (Dali::DaliException e) {
48369       {
48370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48371       };
48372     } catch (...) {
48373       {
48374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48375       };
48376     }
48377   }
48378
48379 }
48380
48381
48382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48383   int jresult ;
48384   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48385   Dali::Camera::Type result;
48386
48387   arg1 = (Dali::CameraActor *)jarg1;
48388   {
48389     try {
48390       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48391     } catch (std::out_of_range& e) {
48392       {
48393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48394       };
48395     } catch (std::exception& e) {
48396       {
48397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48398       };
48399     } catch (Dali::DaliException e) {
48400       {
48401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48402       };
48403     } catch (...) {
48404       {
48405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48406       };
48407     }
48408   }
48409
48410   jresult = (int)result;
48411   return jresult;
48412 }
48413
48414
48415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48416   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48417   Dali::Camera::ProjectionMode arg2 ;
48418
48419   arg1 = (Dali::CameraActor *)jarg1;
48420   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48421   {
48422     try {
48423       (arg1)->SetProjectionMode(arg2);
48424     } catch (std::out_of_range& e) {
48425       {
48426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48427       };
48428     } catch (std::exception& e) {
48429       {
48430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48431       };
48432     } catch (Dali::DaliException e) {
48433       {
48434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48435       };
48436     } catch (...) {
48437       {
48438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48439       };
48440     }
48441   }
48442
48443 }
48444
48445
48446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48447   int jresult ;
48448   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48449   Dali::Camera::ProjectionMode result;
48450
48451   arg1 = (Dali::CameraActor *)jarg1;
48452   {
48453     try {
48454       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48455     } catch (std::out_of_range& e) {
48456       {
48457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48458       };
48459     } catch (std::exception& e) {
48460       {
48461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48462       };
48463     } catch (Dali::DaliException e) {
48464       {
48465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48466       };
48467     } catch (...) {
48468       {
48469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48470       };
48471     }
48472   }
48473
48474   jresult = (int)result;
48475   return jresult;
48476 }
48477
48478
48479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48480   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48481   float arg2 ;
48482
48483   arg1 = (Dali::CameraActor *)jarg1;
48484   arg2 = (float)jarg2;
48485   {
48486     try {
48487       (arg1)->SetFieldOfView(arg2);
48488     } catch (std::out_of_range& e) {
48489       {
48490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48491       };
48492     } catch (std::exception& e) {
48493       {
48494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48495       };
48496     } catch (Dali::DaliException e) {
48497       {
48498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48499       };
48500     } catch (...) {
48501       {
48502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48503       };
48504     }
48505   }
48506
48507 }
48508
48509
48510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48511   float jresult ;
48512   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48513   float result;
48514
48515   arg1 = (Dali::CameraActor *)jarg1;
48516   {
48517     try {
48518       result = (float)(arg1)->GetFieldOfView();
48519     } catch (std::out_of_range& e) {
48520       {
48521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48522       };
48523     } catch (std::exception& e) {
48524       {
48525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48526       };
48527     } catch (Dali::DaliException e) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48530       };
48531     } catch (...) {
48532       {
48533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48534       };
48535     }
48536   }
48537
48538   jresult = result;
48539   return jresult;
48540 }
48541
48542
48543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48544   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48545   float arg2 ;
48546
48547   arg1 = (Dali::CameraActor *)jarg1;
48548   arg2 = (float)jarg2;
48549   {
48550     try {
48551       (arg1)->SetAspectRatio(arg2);
48552     } catch (std::out_of_range& e) {
48553       {
48554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (std::exception& e) {
48557       {
48558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (Dali::DaliException e) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48563       };
48564     } catch (...) {
48565       {
48566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48567       };
48568     }
48569   }
48570
48571 }
48572
48573
48574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48575   float jresult ;
48576   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48577   float result;
48578
48579   arg1 = (Dali::CameraActor *)jarg1;
48580   {
48581     try {
48582       result = (float)(arg1)->GetAspectRatio();
48583     } catch (std::out_of_range& e) {
48584       {
48585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48586       };
48587     } catch (std::exception& e) {
48588       {
48589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48590       };
48591     } catch (Dali::DaliException e) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48594       };
48595     } catch (...) {
48596       {
48597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48598       };
48599     }
48600   }
48601
48602   jresult = result;
48603   return jresult;
48604 }
48605
48606
48607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48608   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48609   float arg2 ;
48610
48611   arg1 = (Dali::CameraActor *)jarg1;
48612   arg2 = (float)jarg2;
48613   {
48614     try {
48615       (arg1)->SetNearClippingPlane(arg2);
48616     } catch (std::out_of_range& e) {
48617       {
48618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48619       };
48620     } catch (std::exception& e) {
48621       {
48622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48623       };
48624     } catch (Dali::DaliException e) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48627       };
48628     } catch (...) {
48629       {
48630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48631       };
48632     }
48633   }
48634
48635 }
48636
48637
48638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48639   float jresult ;
48640   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48641   float result;
48642
48643   arg1 = (Dali::CameraActor *)jarg1;
48644   {
48645     try {
48646       result = (float)(arg1)->GetNearClippingPlane();
48647     } catch (std::out_of_range& e) {
48648       {
48649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48650       };
48651     } catch (std::exception& e) {
48652       {
48653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48654       };
48655     } catch (Dali::DaliException e) {
48656       {
48657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48658       };
48659     } catch (...) {
48660       {
48661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48662       };
48663     }
48664   }
48665
48666   jresult = result;
48667   return jresult;
48668 }
48669
48670
48671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48672   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48673   float arg2 ;
48674
48675   arg1 = (Dali::CameraActor *)jarg1;
48676   arg2 = (float)jarg2;
48677   {
48678     try {
48679       (arg1)->SetFarClippingPlane(arg2);
48680     } catch (std::out_of_range& e) {
48681       {
48682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48683       };
48684     } catch (std::exception& e) {
48685       {
48686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48687       };
48688     } catch (Dali::DaliException e) {
48689       {
48690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48691       };
48692     } catch (...) {
48693       {
48694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48695       };
48696     }
48697   }
48698
48699 }
48700
48701
48702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48703   float jresult ;
48704   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48705   float result;
48706
48707   arg1 = (Dali::CameraActor *)jarg1;
48708   {
48709     try {
48710       result = (float)(arg1)->GetFarClippingPlane();
48711     } catch (std::out_of_range& e) {
48712       {
48713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48714       };
48715     } catch (std::exception& e) {
48716       {
48717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48718       };
48719     } catch (Dali::DaliException e) {
48720       {
48721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48722       };
48723     } catch (...) {
48724       {
48725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48726       };
48727     }
48728   }
48729
48730   jresult = result;
48731   return jresult;
48732 }
48733
48734
48735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48736   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48737   Dali::Vector3 *arg2 = 0 ;
48738
48739   arg1 = (Dali::CameraActor *)jarg1;
48740   arg2 = (Dali::Vector3 *)jarg2;
48741   if (!arg2) {
48742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48743     return ;
48744   }
48745   {
48746     try {
48747       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48748     } catch (std::out_of_range& e) {
48749       {
48750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48751       };
48752     } catch (std::exception& e) {
48753       {
48754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48755       };
48756     } catch (Dali::DaliException e) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48759       };
48760     } catch (...) {
48761       {
48762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48763       };
48764     }
48765   }
48766
48767 }
48768
48769
48770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48771   void * jresult ;
48772   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48773   Dali::Vector3 result;
48774
48775   arg1 = (Dali::CameraActor *)jarg1;
48776   {
48777     try {
48778       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48779     } catch (std::out_of_range& e) {
48780       {
48781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48782       };
48783     } catch (std::exception& e) {
48784       {
48785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48786       };
48787     } catch (Dali::DaliException e) {
48788       {
48789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48790       };
48791     } catch (...) {
48792       {
48793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48794       };
48795     }
48796   }
48797
48798   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48799   return jresult;
48800 }
48801
48802
48803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48804   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48805   bool arg2 ;
48806
48807   arg1 = (Dali::CameraActor *)jarg1;
48808   arg2 = jarg2 ? true : false;
48809   {
48810     try {
48811       (arg1)->SetInvertYAxis(arg2);
48812     } catch (std::out_of_range& e) {
48813       {
48814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48815       };
48816     } catch (std::exception& e) {
48817       {
48818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48819       };
48820     } catch (Dali::DaliException e) {
48821       {
48822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48823       };
48824     } catch (...) {
48825       {
48826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48827       };
48828     }
48829   }
48830
48831 }
48832
48833
48834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48835   unsigned int jresult ;
48836   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48837   bool result;
48838
48839   arg1 = (Dali::CameraActor *)jarg1;
48840   {
48841     try {
48842       result = (bool)(arg1)->GetInvertYAxis();
48843     } catch (std::out_of_range& e) {
48844       {
48845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48846       };
48847     } catch (std::exception& e) {
48848       {
48849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48850       };
48851     } catch (Dali::DaliException e) {
48852       {
48853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48854       };
48855     } catch (...) {
48856       {
48857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48858       };
48859     }
48860   }
48861
48862   jresult = result;
48863   return jresult;
48864 }
48865
48866
48867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48868   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48869   Dali::Size *arg2 = 0 ;
48870
48871   arg1 = (Dali::CameraActor *)jarg1;
48872   arg2 = (Dali::Size *)jarg2;
48873   if (!arg2) {
48874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48875     return ;
48876   }
48877   {
48878     try {
48879       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48880     } catch (std::out_of_range& e) {
48881       {
48882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48883       };
48884     } catch (std::exception& e) {
48885       {
48886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48887       };
48888     } catch (Dali::DaliException e) {
48889       {
48890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48891       };
48892     } catch (...) {
48893       {
48894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48895       };
48896     }
48897   }
48898
48899 }
48900
48901
48902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48903   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48904   Dali::Size *arg2 = 0 ;
48905
48906   arg1 = (Dali::CameraActor *)jarg1;
48907   arg2 = (Dali::Size *)jarg2;
48908   if (!arg2) {
48909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48910     return ;
48911   }
48912   {
48913     try {
48914       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48915     } catch (std::out_of_range& e) {
48916       {
48917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48918       };
48919     } catch (std::exception& e) {
48920       {
48921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48922       };
48923     } catch (Dali::DaliException e) {
48924       {
48925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48926       };
48927     } catch (...) {
48928       {
48929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48930       };
48931     }
48932   }
48933
48934 }
48935
48936
48937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48938   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48939   float arg2 ;
48940   float arg3 ;
48941   float arg4 ;
48942   float arg5 ;
48943   float arg6 ;
48944   float arg7 ;
48945
48946   arg1 = (Dali::CameraActor *)jarg1;
48947   arg2 = (float)jarg2;
48948   arg3 = (float)jarg3;
48949   arg4 = (float)jarg4;
48950   arg5 = (float)jarg5;
48951   arg6 = (float)jarg6;
48952   arg7 = (float)jarg7;
48953   {
48954     try {
48955       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48956     } catch (std::out_of_range& e) {
48957       {
48958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48959       };
48960     } catch (std::exception& e) {
48961       {
48962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48963       };
48964     } catch (Dali::DaliException e) {
48965       {
48966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48967       };
48968     } catch (...) {
48969       {
48970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48971       };
48972     }
48973   }
48974
48975 }
48976
48977
48978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48979   void * jresult ;
48980   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48981
48982   {
48983     try {
48984       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48985     } catch (std::out_of_range& e) {
48986       {
48987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48988       };
48989     } catch (std::exception& e) {
48990       {
48991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48992       };
48993     } catch (Dali::DaliException e) {
48994       {
48995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48996       };
48997     } catch (...) {
48998       {
48999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49000       };
49001     }
49002   }
49003
49004   jresult = (void *)result;
49005   return jresult;
49006 }
49007
49008
49009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49010   void * jresult ;
49011   std::string arg1 ;
49012   Dali::Property::Value arg2 ;
49013   Dali::Property::Value *argp2 ;
49014   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49015
49016   if (!jarg1) {
49017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49018     return 0;
49019   }
49020   (&arg1)->assign(jarg1);
49021   argp2 = (Dali::Property::Value *)jarg2;
49022   if (!argp2) {
49023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49024     return 0;
49025   }
49026   arg2 = *argp2;
49027   {
49028     try {
49029       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49030     } catch (std::out_of_range& e) {
49031       {
49032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49033       };
49034     } catch (std::exception& e) {
49035       {
49036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49037       };
49038     } catch (Dali::DaliException e) {
49039       {
49040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49041       };
49042     } catch (...) {
49043       {
49044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49045       };
49046     }
49047   }
49048
49049   jresult = (void *)result;
49050   return jresult;
49051 }
49052
49053
49054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49055   void * jresult ;
49056   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49057   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49058
49059   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49060   if (!arg1) {
49061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49062     return 0;
49063   }
49064   {
49065     try {
49066       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);
49067     } catch (std::out_of_range& e) {
49068       {
49069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49070       };
49071     } catch (std::exception& e) {
49072       {
49073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49074       };
49075     } catch (Dali::DaliException e) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49078       };
49079     } catch (...) {
49080       {
49081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49082       };
49083     }
49084   }
49085
49086   jresult = (void *)result;
49087   return jresult;
49088 }
49089
49090
49091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49092   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49093   std::string *arg2 = 0 ;
49094
49095   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49096   if (!jarg2) {
49097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49098     return ;
49099   }
49100   std::string arg2_str(jarg2);
49101   arg2 = &arg2_str;
49102   if (arg1) (arg1)->first = *arg2;
49103
49104   //argout typemap for const std::string&
49105
49106 }
49107
49108
49109 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49110   char * jresult ;
49111   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49112   std::string *result = 0 ;
49113
49114   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49115   result = (std::string *) & ((arg1)->first);
49116   jresult = SWIG_csharp_string_callback(result->c_str());
49117   return jresult;
49118 }
49119
49120
49121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49122   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49123   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49124
49125   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49126   arg2 = (Dali::Property::Value *)jarg2;
49127   if (arg1) (arg1)->second = *arg2;
49128 }
49129
49130
49131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49132   void * jresult ;
49133   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49134   Dali::Property::Value *result = 0 ;
49135
49136   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49137   result = (Dali::Property::Value *)& ((arg1)->second);
49138   jresult = (void *)result;
49139   return jresult;
49140 }
49141
49142
49143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49144   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49145
49146   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49147   {
49148     try {
49149       delete arg1;
49150     } catch (std::out_of_range& e) {
49151       {
49152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49153       };
49154     } catch (std::exception& e) {
49155       {
49156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49157       };
49158     } catch (Dali::DaliException e) {
49159       {
49160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49161       };
49162     } catch (...) {
49163       {
49164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49165       };
49166     }
49167   }
49168
49169 }
49170
49171
49172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49173   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49174
49175   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49176   {
49177     try {
49178       (arg1)->clear();
49179     } catch (std::out_of_range& e) {
49180       {
49181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49182       };
49183     } catch (std::exception& e) {
49184       {
49185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49186       };
49187     } catch (Dali::DaliException e) {
49188       {
49189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49190       };
49191     } catch (...) {
49192       {
49193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49194       };
49195     }
49196   }
49197
49198 }
49199
49200
49201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49202   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49203   Dali::TouchPoint *arg2 = 0 ;
49204
49205   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49206   arg2 = (Dali::TouchPoint *)jarg2;
49207   if (!arg2) {
49208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49209     return ;
49210   }
49211   {
49212     try {
49213       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49214     } catch (std::out_of_range& e) {
49215       {
49216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49217       };
49218     } catch (std::exception& e) {
49219       {
49220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49221       };
49222     } catch (Dali::DaliException e) {
49223       {
49224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49225       };
49226     } catch (...) {
49227       {
49228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49229       };
49230     }
49231   }
49232
49233 }
49234
49235
49236 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49237   unsigned long jresult ;
49238   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49239   std::vector< Dali::TouchPoint >::size_type result;
49240
49241   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49242   {
49243     try {
49244       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49245     } catch (std::out_of_range& e) {
49246       {
49247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49248       };
49249     } catch (std::exception& e) {
49250       {
49251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49252       };
49253     } catch (Dali::DaliException e) {
49254       {
49255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49256       };
49257     } catch (...) {
49258       {
49259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49260       };
49261     }
49262   }
49263
49264   jresult = (unsigned long)result;
49265   return jresult;
49266 }
49267
49268
49269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49270   unsigned long jresult ;
49271   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49272   std::vector< Dali::TouchPoint >::size_type result;
49273
49274   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49275   {
49276     try {
49277       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49278     } catch (std::out_of_range& e) {
49279       {
49280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49281       };
49282     } catch (std::exception& e) {
49283       {
49284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49285       };
49286     } catch (Dali::DaliException e) {
49287       {
49288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49289       };
49290     } catch (...) {
49291       {
49292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49293       };
49294     }
49295   }
49296
49297   jresult = (unsigned long)result;
49298   return jresult;
49299 }
49300
49301
49302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49303   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49304   std::vector< Dali::TouchPoint >::size_type arg2 ;
49305
49306   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49307   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49308   {
49309     try {
49310       (arg1)->reserve(arg2);
49311     } catch (std::out_of_range& e) {
49312       {
49313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49314       };
49315     } catch (std::exception& e) {
49316       {
49317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49318       };
49319     } catch (Dali::DaliException e) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49322       };
49323     } catch (...) {
49324       {
49325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49326       };
49327     }
49328   }
49329
49330 }
49331
49332
49333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49334   void * jresult ;
49335   std::vector< Dali::TouchPoint > *result = 0 ;
49336
49337   {
49338     try {
49339       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49340     } catch (std::out_of_range& e) {
49341       {
49342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49343       };
49344     } catch (std::exception& e) {
49345       {
49346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49347       };
49348     } catch (Dali::DaliException e) {
49349       {
49350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49351       };
49352     } catch (...) {
49353       {
49354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49355       };
49356     }
49357   }
49358
49359   jresult = (void *)result;
49360   return jresult;
49361 }
49362
49363
49364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49365   void * jresult ;
49366   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49367   std::vector< Dali::TouchPoint > *result = 0 ;
49368
49369   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49370   if (!arg1) {
49371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49372     return 0;
49373   }
49374   {
49375     try {
49376       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49377     } catch (std::out_of_range& e) {
49378       {
49379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49380       };
49381     } catch (std::exception& e) {
49382       {
49383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49384       };
49385     } catch (Dali::DaliException e) {
49386       {
49387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49388       };
49389     } catch (...) {
49390       {
49391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49392       };
49393     }
49394   }
49395
49396   jresult = (void *)result;
49397   return jresult;
49398 }
49399
49400
49401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49402   void * jresult ;
49403   int arg1 ;
49404   std::vector< Dali::TouchPoint > *result = 0 ;
49405
49406   arg1 = (int)jarg1;
49407   {
49408     try {
49409       try {
49410         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49411       }
49412       catch(std::out_of_range &_e) {
49413         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49414         return 0;
49415       }
49416
49417     } catch (std::out_of_range& e) {
49418       {
49419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49420       };
49421     } catch (std::exception& e) {
49422       {
49423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49424       };
49425     } catch (Dali::DaliException e) {
49426       {
49427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49428       };
49429     } catch (...) {
49430       {
49431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49432       };
49433     }
49434   }
49435
49436   jresult = (void *)result;
49437   return jresult;
49438 }
49439
49440
49441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49442   void * jresult ;
49443   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49444   int arg2 ;
49445   SwigValueWrapper< Dali::TouchPoint > result;
49446
49447   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49448   arg2 = (int)jarg2;
49449   {
49450     try {
49451       try {
49452         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49453       }
49454       catch(std::out_of_range &_e) {
49455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49456         return 0;
49457       }
49458
49459     } catch (std::out_of_range& e) {
49460       {
49461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (std::exception& e) {
49464       {
49465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (Dali::DaliException e) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49470       };
49471     } catch (...) {
49472       {
49473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49474       };
49475     }
49476   }
49477
49478   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49484   void * jresult ;
49485   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49486   int arg2 ;
49487   Dali::TouchPoint *result = 0 ;
49488
49489   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49490   arg2 = (int)jarg2;
49491   {
49492     try {
49493       try {
49494         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49495       }
49496       catch(std::out_of_range &_e) {
49497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49498         return 0;
49499       }
49500
49501     } catch (std::out_of_range& e) {
49502       {
49503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49504       };
49505     } catch (std::exception& e) {
49506       {
49507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49508       };
49509     } catch (Dali::DaliException e) {
49510       {
49511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49512       };
49513     } catch (...) {
49514       {
49515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49516       };
49517     }
49518   }
49519
49520   jresult = (void *)result;
49521   return jresult;
49522 }
49523
49524
49525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49526   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49527   int arg2 ;
49528   Dali::TouchPoint *arg3 = 0 ;
49529
49530   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49531   arg2 = (int)jarg2;
49532   arg3 = (Dali::TouchPoint *)jarg3;
49533   if (!arg3) {
49534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49535     return ;
49536   }
49537   {
49538     try {
49539       try {
49540         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49541       }
49542       catch(std::out_of_range &_e) {
49543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49544         return ;
49545       }
49546
49547     } catch (std::out_of_range& e) {
49548       {
49549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49550       };
49551     } catch (std::exception& e) {
49552       {
49553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49554       };
49555     } catch (Dali::DaliException e) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49558       };
49559     } catch (...) {
49560       {
49561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49562       };
49563     }
49564   }
49565
49566 }
49567
49568
49569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49570   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49571   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49572
49573   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49574   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49575   if (!arg2) {
49576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49577     return ;
49578   }
49579   {
49580     try {
49581       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49582     } catch (std::out_of_range& e) {
49583       {
49584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49585       };
49586     } catch (std::exception& e) {
49587       {
49588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49589       };
49590     } catch (Dali::DaliException e) {
49591       {
49592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49593       };
49594     } catch (...) {
49595       {
49596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49597       };
49598     }
49599   }
49600
49601 }
49602
49603
49604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49605   void * jresult ;
49606   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49607   int arg2 ;
49608   int arg3 ;
49609   std::vector< Dali::TouchPoint > *result = 0 ;
49610
49611   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49612   arg2 = (int)jarg2;
49613   arg3 = (int)jarg3;
49614   {
49615     try {
49616       try {
49617         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49618       }
49619       catch(std::out_of_range &_e) {
49620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49621         return 0;
49622       }
49623       catch(std::invalid_argument &_e) {
49624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49625         return 0;
49626       }
49627
49628     } catch (std::out_of_range& e) {
49629       {
49630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49631       };
49632     } catch (std::exception& e) {
49633       {
49634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49635       };
49636     } catch (Dali::DaliException e) {
49637       {
49638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49639       };
49640     } catch (...) {
49641       {
49642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49643       };
49644     }
49645   }
49646
49647   jresult = (void *)result;
49648   return jresult;
49649 }
49650
49651
49652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49653   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49654   int arg2 ;
49655   Dali::TouchPoint *arg3 = 0 ;
49656
49657   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49658   arg2 = (int)jarg2;
49659   arg3 = (Dali::TouchPoint *)jarg3;
49660   if (!arg3) {
49661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49662     return ;
49663   }
49664   {
49665     try {
49666       try {
49667         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49668       }
49669       catch(std::out_of_range &_e) {
49670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49671         return ;
49672       }
49673
49674     } catch (std::out_of_range& e) {
49675       {
49676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (std::exception& e) {
49679       {
49680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49681       };
49682     } catch (Dali::DaliException e) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49685       };
49686     } catch (...) {
49687       {
49688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49689       };
49690     }
49691   }
49692
49693 }
49694
49695
49696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49697   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49698   int arg2 ;
49699   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49700
49701   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49702   arg2 = (int)jarg2;
49703   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49704   if (!arg3) {
49705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49706     return ;
49707   }
49708   {
49709     try {
49710       try {
49711         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49712       }
49713       catch(std::out_of_range &_e) {
49714         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49715         return ;
49716       }
49717
49718     } catch (std::out_of_range& e) {
49719       {
49720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49721       };
49722     } catch (std::exception& e) {
49723       {
49724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49725       };
49726     } catch (Dali::DaliException e) {
49727       {
49728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49729       };
49730     } catch (...) {
49731       {
49732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49733       };
49734     }
49735   }
49736
49737 }
49738
49739
49740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49741   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49742   int arg2 ;
49743
49744   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49745   arg2 = (int)jarg2;
49746   {
49747     try {
49748       try {
49749         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49750       }
49751       catch(std::out_of_range &_e) {
49752         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49753         return ;
49754       }
49755
49756     } catch (std::out_of_range& e) {
49757       {
49758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (std::exception& e) {
49761       {
49762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (Dali::DaliException e) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49767       };
49768     } catch (...) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49771       };
49772     }
49773   }
49774
49775 }
49776
49777
49778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49779   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49780   int arg2 ;
49781   int arg3 ;
49782
49783   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49784   arg2 = (int)jarg2;
49785   arg3 = (int)jarg3;
49786   {
49787     try {
49788       try {
49789         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49790       }
49791       catch(std::out_of_range &_e) {
49792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49793         return ;
49794       }
49795       catch(std::invalid_argument &_e) {
49796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49797         return ;
49798       }
49799
49800     } catch (std::out_of_range& e) {
49801       {
49802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49803       };
49804     } catch (std::exception& e) {
49805       {
49806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49807       };
49808     } catch (Dali::DaliException e) {
49809       {
49810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49811       };
49812     } catch (...) {
49813       {
49814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49815       };
49816     }
49817   }
49818
49819 }
49820
49821
49822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49823   void * jresult ;
49824   Dali::TouchPoint *arg1 = 0 ;
49825   int arg2 ;
49826   std::vector< Dali::TouchPoint > *result = 0 ;
49827
49828   arg1 = (Dali::TouchPoint *)jarg1;
49829   if (!arg1) {
49830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49831     return 0;
49832   }
49833   arg2 = (int)jarg2;
49834   {
49835     try {
49836       try {
49837         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49838       }
49839       catch(std::out_of_range &_e) {
49840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49841         return 0;
49842       }
49843
49844     } catch (std::out_of_range& e) {
49845       {
49846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49847       };
49848     } catch (std::exception& e) {
49849       {
49850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49851       };
49852     } catch (Dali::DaliException e) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49855       };
49856     } catch (...) {
49857       {
49858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49859       };
49860     }
49861   }
49862
49863   jresult = (void *)result;
49864   return jresult;
49865 }
49866
49867
49868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49869   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49870
49871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49872   {
49873     try {
49874       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49875     } catch (std::out_of_range& e) {
49876       {
49877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49878       };
49879     } catch (std::exception& e) {
49880       {
49881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49882       };
49883     } catch (Dali::DaliException e) {
49884       {
49885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49886       };
49887     } catch (...) {
49888       {
49889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49890       };
49891     }
49892   }
49893
49894 }
49895
49896
49897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49898   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49899   int arg2 ;
49900   int arg3 ;
49901
49902   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49903   arg2 = (int)jarg2;
49904   arg3 = (int)jarg3;
49905   {
49906     try {
49907       try {
49908         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49909       }
49910       catch(std::out_of_range &_e) {
49911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49912         return ;
49913       }
49914       catch(std::invalid_argument &_e) {
49915         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49916         return ;
49917       }
49918
49919     } catch (std::out_of_range& e) {
49920       {
49921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49922       };
49923     } catch (std::exception& e) {
49924       {
49925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49926       };
49927     } catch (Dali::DaliException e) {
49928       {
49929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49930       };
49931     } catch (...) {
49932       {
49933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49934       };
49935     }
49936   }
49937
49938 }
49939
49940
49941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49942   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49943   int arg2 ;
49944   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49945
49946   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49947   arg2 = (int)jarg2;
49948   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49949   if (!arg3) {
49950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49951     return ;
49952   }
49953   {
49954     try {
49955       try {
49956         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49957       }
49958       catch(std::out_of_range &_e) {
49959         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49960         return ;
49961       }
49962
49963     } catch (std::out_of_range& e) {
49964       {
49965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (std::exception& e) {
49968       {
49969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49970       };
49971     } catch (Dali::DaliException e) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49974       };
49975     } catch (...) {
49976       {
49977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49978       };
49979     }
49980   }
49981
49982 }
49983
49984
49985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49986   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49987
49988   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49989   {
49990     try {
49991       delete arg1;
49992     } catch (std::out_of_range& e) {
49993       {
49994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49995       };
49996     } catch (std::exception& e) {
49997       {
49998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49999       };
50000     } catch (Dali::DaliException e) {
50001       {
50002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50003       };
50004     } catch (...) {
50005       {
50006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50007       };
50008     }
50009   }
50010
50011 }
50012
50013
50014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50015   void * jresult ;
50016   Dali::Rect< int > *result = 0 ;
50017
50018   {
50019     try {
50020       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50021     } catch (std::out_of_range& e) {
50022       {
50023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50024       };
50025     } catch (std::exception& e) {
50026       {
50027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50028       };
50029     } catch (Dali::DaliException e) {
50030       {
50031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50032       };
50033     } catch (...) {
50034       {
50035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50036       };
50037     }
50038   }
50039
50040   jresult = (void *)result;
50041   return jresult;
50042 }
50043
50044
50045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50046   void * jresult ;
50047   int arg1 ;
50048   int arg2 ;
50049   int arg3 ;
50050   int arg4 ;
50051   Dali::Rect< int > *result = 0 ;
50052
50053   arg1 = (int)jarg1;
50054   arg2 = (int)jarg2;
50055   arg3 = (int)jarg3;
50056   arg4 = (int)jarg4;
50057   {
50058     try {
50059       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50060     } catch (std::out_of_range& e) {
50061       {
50062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50063       };
50064     } catch (std::exception& e) {
50065       {
50066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50067       };
50068     } catch (Dali::DaliException e) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50071       };
50072     } catch (...) {
50073       {
50074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50075       };
50076     }
50077   }
50078
50079   jresult = (void *)result;
50080   return jresult;
50081 }
50082
50083
50084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50085   void * jresult ;
50086   Dali::Rect< int > *arg1 = 0 ;
50087   Dali::Rect< int > *result = 0 ;
50088
50089   arg1 = (Dali::Rect< int > *)jarg1;
50090   if (!arg1) {
50091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50092     return 0;
50093   }
50094   {
50095     try {
50096       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50097     } catch (std::out_of_range& e) {
50098       {
50099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50100       };
50101     } catch (std::exception& e) {
50102       {
50103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50104       };
50105     } catch (Dali::DaliException e) {
50106       {
50107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50108       };
50109     } catch (...) {
50110       {
50111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50112       };
50113     }
50114   }
50115
50116   jresult = (void *)result;
50117   return jresult;
50118 }
50119
50120
50121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50122   void * jresult ;
50123   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50124   Dali::Rect< int > *arg2 = 0 ;
50125   Dali::Rect< int > *result = 0 ;
50126
50127   arg1 = (Dali::Rect< int > *)jarg1;
50128   arg2 = (Dali::Rect< int > *)jarg2;
50129   if (!arg2) {
50130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50131     return 0;
50132   }
50133   {
50134     try {
50135       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50136     } catch (std::out_of_range& e) {
50137       {
50138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50139       };
50140     } catch (std::exception& e) {
50141       {
50142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50143       };
50144     } catch (Dali::DaliException e) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50147       };
50148     } catch (...) {
50149       {
50150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50151       };
50152     }
50153   }
50154
50155   jresult = (void *)result;
50156   return jresult;
50157 }
50158
50159
50160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50161   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50162   int arg2 ;
50163   int arg3 ;
50164   int arg4 ;
50165   int arg5 ;
50166
50167   arg1 = (Dali::Rect< int > *)jarg1;
50168   arg2 = (int)jarg2;
50169   arg3 = (int)jarg3;
50170   arg4 = (int)jarg4;
50171   arg5 = (int)jarg5;
50172   {
50173     try {
50174       (arg1)->Set(arg2,arg3,arg4,arg5);
50175     } catch (std::out_of_range& e) {
50176       {
50177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50178       };
50179     } catch (std::exception& e) {
50180       {
50181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50182       };
50183     } catch (Dali::DaliException e) {
50184       {
50185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50186       };
50187     } catch (...) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50190       };
50191     }
50192   }
50193
50194 }
50195
50196
50197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50198   unsigned int jresult ;
50199   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50200   bool result;
50201
50202   arg1 = (Dali::Rect< int > *)jarg1;
50203   {
50204     try {
50205       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50206     } catch (std::out_of_range& e) {
50207       {
50208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50209       };
50210     } catch (std::exception& e) {
50211       {
50212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50213       };
50214     } catch (Dali::DaliException e) {
50215       {
50216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50217       };
50218     } catch (...) {
50219       {
50220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50221       };
50222     }
50223   }
50224
50225   jresult = result;
50226   return jresult;
50227 }
50228
50229
50230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50231   int jresult ;
50232   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50233   int result;
50234
50235   arg1 = (Dali::Rect< int > *)jarg1;
50236   {
50237     try {
50238       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50239     } catch (std::out_of_range& e) {
50240       {
50241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50242       };
50243     } catch (std::exception& e) {
50244       {
50245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50246       };
50247     } catch (Dali::DaliException e) {
50248       {
50249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50250       };
50251     } catch (...) {
50252       {
50253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50254       };
50255     }
50256   }
50257
50258   jresult = result;
50259   return jresult;
50260 }
50261
50262
50263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50264   int jresult ;
50265   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50266   int result;
50267
50268   arg1 = (Dali::Rect< int > *)jarg1;
50269   {
50270     try {
50271       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50272     } catch (std::out_of_range& e) {
50273       {
50274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50275       };
50276     } catch (std::exception& e) {
50277       {
50278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50279       };
50280     } catch (Dali::DaliException e) {
50281       {
50282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50283       };
50284     } catch (...) {
50285       {
50286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50287       };
50288     }
50289   }
50290
50291   jresult = result;
50292   return jresult;
50293 }
50294
50295
50296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50297   int jresult ;
50298   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50299   int result;
50300
50301   arg1 = (Dali::Rect< int > *)jarg1;
50302   {
50303     try {
50304       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50305     } catch (std::out_of_range& e) {
50306       {
50307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50308       };
50309     } catch (std::exception& e) {
50310       {
50311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50312       };
50313     } catch (Dali::DaliException e) {
50314       {
50315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50316       };
50317     } catch (...) {
50318       {
50319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50320       };
50321     }
50322   }
50323
50324   jresult = result;
50325   return jresult;
50326 }
50327
50328
50329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50330   int jresult ;
50331   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50332   int result;
50333
50334   arg1 = (Dali::Rect< int > *)jarg1;
50335   {
50336     try {
50337       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50338     } catch (std::out_of_range& e) {
50339       {
50340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50341       };
50342     } catch (std::exception& e) {
50343       {
50344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50345       };
50346     } catch (Dali::DaliException e) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50349       };
50350     } catch (...) {
50351       {
50352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50353       };
50354     }
50355   }
50356
50357   jresult = result;
50358   return jresult;
50359 }
50360
50361
50362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50363   int jresult ;
50364   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50365   int result;
50366
50367   arg1 = (Dali::Rect< int > *)jarg1;
50368   {
50369     try {
50370       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50371     } catch (std::out_of_range& e) {
50372       {
50373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (std::exception& e) {
50376       {
50377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50378       };
50379     } catch (Dali::DaliException e) {
50380       {
50381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50382       };
50383     } catch (...) {
50384       {
50385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50386       };
50387     }
50388   }
50389
50390   jresult = result;
50391   return jresult;
50392 }
50393
50394
50395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50396   unsigned int jresult ;
50397   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50398   Dali::Rect< int > *arg2 = 0 ;
50399   bool result;
50400
50401   arg1 = (Dali::Rect< int > *)jarg1;
50402   arg2 = (Dali::Rect< int > *)jarg2;
50403   if (!arg2) {
50404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50405     return 0;
50406   }
50407   {
50408     try {
50409       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50410     } catch (std::out_of_range& e) {
50411       {
50412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50413       };
50414     } catch (std::exception& e) {
50415       {
50416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50417       };
50418     } catch (Dali::DaliException e) {
50419       {
50420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50421       };
50422     } catch (...) {
50423       {
50424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50425       };
50426     }
50427   }
50428
50429   jresult = result;
50430   return jresult;
50431 }
50432
50433
50434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50435   unsigned int jresult ;
50436   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50437   Dali::Rect< int > *arg2 = 0 ;
50438   bool result;
50439
50440   arg1 = (Dali::Rect< int > *)jarg1;
50441   arg2 = (Dali::Rect< int > *)jarg2;
50442   if (!arg2) {
50443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50444     return 0;
50445   }
50446   {
50447     try {
50448       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50449     } catch (std::out_of_range& e) {
50450       {
50451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50452       };
50453     } catch (std::exception& e) {
50454       {
50455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50456       };
50457     } catch (Dali::DaliException e) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50460       };
50461     } catch (...) {
50462       {
50463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50464       };
50465     }
50466   }
50467
50468   jresult = result;
50469   return jresult;
50470 }
50471
50472
50473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50474   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50475   int arg2 ;
50476
50477   arg1 = (Dali::Rect< int > *)jarg1;
50478   arg2 = (int)jarg2;
50479   if (arg1) (arg1)->x = arg2;
50480 }
50481
50482
50483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50484   int jresult ;
50485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50486   int result;
50487
50488   arg1 = (Dali::Rect< int > *)jarg1;
50489   result = (int) ((arg1)->x);
50490   jresult = result;
50491   return jresult;
50492 }
50493
50494
50495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50496   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50497   int arg2 ;
50498
50499   arg1 = (Dali::Rect< int > *)jarg1;
50500   arg2 = (int)jarg2;
50501   if (arg1) (arg1)->left = arg2;
50502 }
50503
50504
50505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50506   int jresult ;
50507   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50508   int result;
50509
50510   arg1 = (Dali::Rect< int > *)jarg1;
50511   result = (int) ((arg1)->left);
50512   jresult = result;
50513   return jresult;
50514 }
50515
50516
50517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50518   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50519   int arg2 ;
50520
50521   arg1 = (Dali::Rect< int > *)jarg1;
50522   arg2 = (int)jarg2;
50523   if (arg1) (arg1)->y = arg2;
50524 }
50525
50526
50527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50528   int jresult ;
50529   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50530   int result;
50531
50532   arg1 = (Dali::Rect< int > *)jarg1;
50533   result = (int) ((arg1)->y);
50534   jresult = result;
50535   return jresult;
50536 }
50537
50538
50539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50540   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50541   int arg2 ;
50542
50543   arg1 = (Dali::Rect< int > *)jarg1;
50544   arg2 = (int)jarg2;
50545   if (arg1) (arg1)->right = arg2;
50546 }
50547
50548
50549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50550   int jresult ;
50551   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50552   int result;
50553
50554   arg1 = (Dali::Rect< int > *)jarg1;
50555   result = (int) ((arg1)->right);
50556   jresult = result;
50557   return jresult;
50558 }
50559
50560
50561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50562   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50563   int arg2 ;
50564
50565   arg1 = (Dali::Rect< int > *)jarg1;
50566   arg2 = (int)jarg2;
50567   if (arg1) (arg1)->width = arg2;
50568 }
50569
50570
50571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50572   int jresult ;
50573   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50574   int result;
50575
50576   arg1 = (Dali::Rect< int > *)jarg1;
50577   result = (int) ((arg1)->width);
50578   jresult = result;
50579   return jresult;
50580 }
50581
50582
50583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50585   int arg2 ;
50586
50587   arg1 = (Dali::Rect< int > *)jarg1;
50588   arg2 = (int)jarg2;
50589   if (arg1) (arg1)->bottom = arg2;
50590 }
50591
50592
50593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50594   int jresult ;
50595   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50596   int result;
50597
50598   arg1 = (Dali::Rect< int > *)jarg1;
50599   result = (int) ((arg1)->bottom);
50600   jresult = result;
50601   return jresult;
50602 }
50603
50604
50605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50606   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50607   int arg2 ;
50608
50609   arg1 = (Dali::Rect< int > *)jarg1;
50610   arg2 = (int)jarg2;
50611   if (arg1) (arg1)->height = arg2;
50612 }
50613
50614
50615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50616   int jresult ;
50617   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50618   int result;
50619
50620   arg1 = (Dali::Rect< int > *)jarg1;
50621   result = (int) ((arg1)->height);
50622   jresult = result;
50623   return jresult;
50624 }
50625
50626
50627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50628   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50629   int arg2 ;
50630
50631   arg1 = (Dali::Rect< int > *)jarg1;
50632   arg2 = (int)jarg2;
50633   if (arg1) (arg1)->top = arg2;
50634 }
50635
50636
50637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50638   int jresult ;
50639   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50640   int result;
50641
50642   arg1 = (Dali::Rect< int > *)jarg1;
50643   result = (int) ((arg1)->top);
50644   jresult = result;
50645   return jresult;
50646 }
50647
50648
50649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50650   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50651
50652   arg1 = (Dali::Rect< int > *)jarg1;
50653   {
50654     try {
50655       delete arg1;
50656     } catch (std::out_of_range& e) {
50657       {
50658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50659       };
50660     } catch (std::exception& e) {
50661       {
50662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50663       };
50664     } catch (Dali::DaliException e) {
50665       {
50666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50667       };
50668     } catch (...) {
50669       {
50670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50671       };
50672     }
50673   }
50674
50675 }
50676
50677
50678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50679   void * jresult ;
50680   Dali::Rect< float > *result = 0 ;
50681
50682   {
50683     try {
50684       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50685     } catch (std::out_of_range& e) {
50686       {
50687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50688       };
50689     } catch (std::exception& e) {
50690       {
50691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50692       };
50693     } catch (Dali::DaliException e) {
50694       {
50695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50696       };
50697     } catch (...) {
50698       {
50699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50700       };
50701     }
50702   }
50703
50704   jresult = (void *)result;
50705   return jresult;
50706 }
50707
50708
50709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50710   void * jresult ;
50711   float arg1 ;
50712   float arg2 ;
50713   float arg3 ;
50714   float arg4 ;
50715   Dali::Rect< float > *result = 0 ;
50716
50717   arg1 = (float)jarg1;
50718   arg2 = (float)jarg2;
50719   arg3 = (float)jarg4;
50720   arg4 = (float)jarg3;
50721   {
50722     try {
50723       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50724     } catch (std::out_of_range& e) {
50725       {
50726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50727       };
50728     } catch (std::exception& e) {
50729       {
50730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50731       };
50732     } catch (Dali::DaliException e) {
50733       {
50734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50735       };
50736     } catch (...) {
50737       {
50738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50739       };
50740     }
50741   }
50742
50743   jresult = (void *)result;
50744   return jresult;
50745 }
50746
50747
50748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50749   void * jresult ;
50750   Dali::Rect< float > *arg1 = 0 ;
50751   Dali::Rect< float > *result = 0 ;
50752
50753   arg1 = (Dali::Rect< float > *)jarg1;
50754   if (!arg1) {
50755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50756     return 0;
50757   }
50758   {
50759     try {
50760       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50761     } catch (std::out_of_range& e) {
50762       {
50763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50764       };
50765     } catch (std::exception& e) {
50766       {
50767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50768       };
50769     } catch (Dali::DaliException e) {
50770       {
50771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50772       };
50773     } catch (...) {
50774       {
50775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50776       };
50777     }
50778   }
50779
50780   jresult = (void *)result;
50781   return jresult;
50782 }
50783
50784
50785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50786   void * jresult ;
50787   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50788   Dali::Rect< float > *arg2 = 0 ;
50789   Dali::Rect< float > *result = 0 ;
50790
50791   arg1 = (Dali::Rect< float > *)jarg1;
50792   arg2 = (Dali::Rect< float > *)jarg2;
50793   if (!arg2) {
50794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50795     return 0;
50796   }
50797   {
50798     try {
50799       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50800     } catch (std::out_of_range& e) {
50801       {
50802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50803       };
50804     } catch (std::exception& e) {
50805       {
50806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50807       };
50808     } catch (Dali::DaliException e) {
50809       {
50810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50811       };
50812     } catch (...) {
50813       {
50814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50815       };
50816     }
50817   }
50818
50819   jresult = (void *)result;
50820   return jresult;
50821 }
50822
50823
50824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50825   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50826   float arg2 ;
50827   float arg3 ;
50828   float arg4 ;
50829   float arg5 ;
50830
50831   arg1 = (Dali::Rect< float > *)jarg1;
50832   arg2 = (float)jarg2;
50833   arg3 = (float)jarg3;
50834   arg4 = (float)jarg5;
50835   arg5 = (float)jarg4;
50836   {
50837     try {
50838       (arg1)->Set(arg2,arg3,arg4,arg5);
50839     } catch (std::out_of_range& e) {
50840       {
50841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50842       };
50843     } catch (std::exception& e) {
50844       {
50845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50846       };
50847     } catch (Dali::DaliException e) {
50848       {
50849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50850       };
50851     } catch (...) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50854       };
50855     }
50856   }
50857
50858 }
50859
50860
50861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50862   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50863   float arg2 ;
50864
50865   arg1 = (Dali::Rect< float > *)jarg1;
50866   arg2 = (float)jarg2;
50867   if (arg1) (arg1)->left = arg2;
50868 }
50869
50870
50871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50872   float jresult ;
50873   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50874   float result;
50875
50876   arg1 = (Dali::Rect< float > *)jarg1;
50877   result = (float) ((arg1)->left);
50878   jresult = result;
50879   return jresult;
50880 }
50881
50882
50883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50884   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50885   float arg2 ;
50886
50887   arg1 = (Dali::Rect< float > *)jarg1;
50888   arg2 = (float)jarg2;
50889   if (arg1) (arg1)->left = arg2;
50890 }
50891
50892
50893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50894   float jresult ;
50895   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50896   float result;
50897
50898   arg1 = (Dali::Rect< float > *)jarg1;
50899   result = (float) ((arg1)->left);
50900   jresult = result;
50901   return jresult;
50902 }
50903
50904
50905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50906   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50907   float arg2 ;
50908
50909   arg1 = (Dali::Rect< float > *)jarg1;
50910   arg2 = (float)jarg2;
50911   if (arg1) (arg1)->right = arg2;
50912 }
50913
50914
50915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50916   float jresult ;
50917   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50918   float result;
50919
50920   arg1 = (Dali::Rect< float > *)jarg1;
50921   result = (float) ((arg1)->right);
50922   jresult = result;
50923   return jresult;
50924 }
50925
50926
50927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50928   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50929   float arg2 ;
50930
50931   arg1 = (Dali::Rect< float > *)jarg1;
50932   arg2 = (float)jarg2;
50933   if (arg1) (arg1)->right = arg2;
50934 }
50935
50936
50937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50938   float jresult ;
50939   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50940   float result;
50941
50942   arg1 = (Dali::Rect< float > *)jarg1;
50943   result = (float) ((arg1)->right);
50944   jresult = result;
50945   return jresult;
50946 }
50947
50948
50949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50950   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50951   float arg2 ;
50952
50953   arg1 = (Dali::Rect< float > *)jarg1;
50954   arg2 = (float)jarg2;
50955   if (arg1) (arg1)->bottom = arg2;
50956 }
50957
50958
50959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50960   float jresult ;
50961   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50962   float result;
50963
50964   arg1 = (Dali::Rect< float > *)jarg1;
50965   result = (float) ((arg1)->bottom);
50966   jresult = result;
50967   return jresult;
50968 }
50969
50970
50971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50972   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50973   float arg2 ;
50974
50975   arg1 = (Dali::Rect< float > *)jarg1;
50976   arg2 = (float)jarg2;
50977   if (arg1) (arg1)->top = arg2;
50978 }
50979
50980
50981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50982   float jresult ;
50983   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50984   float result;
50985
50986   arg1 = (Dali::Rect< float > *)jarg1;
50987   result = (float) ((arg1)->top);
50988   jresult = result;
50989   return jresult;
50990 }
50991
50992
50993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50994   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50995
50996   arg1 = (Dali::Rect< float > *)jarg1;
50997   {
50998     try {
50999       delete arg1;
51000     } catch (std::out_of_range& e) {
51001       {
51002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (std::exception& e) {
51005       {
51006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51007       };
51008     } catch (Dali::DaliException e) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51011       };
51012     } catch (...) {
51013       {
51014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51015       };
51016     }
51017   }
51018
51019 }
51020
51021
51022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51023   int jresult ;
51024   int result;
51025
51026   result = (int)Dali::Vector< int >::BaseType;
51027   jresult = (int)result;
51028   return jresult;
51029 }
51030
51031
51032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51033   void * jresult ;
51034   Dali::Vector< int > *result = 0 ;
51035
51036   {
51037     try {
51038       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51039     } catch (std::out_of_range& e) {
51040       {
51041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51042       };
51043     } catch (std::exception& e) {
51044       {
51045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51046       };
51047     } catch (Dali::DaliException e) {
51048       {
51049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51050       };
51051     } catch (...) {
51052       {
51053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51054       };
51055     }
51056   }
51057
51058   jresult = (void *)result;
51059   return jresult;
51060 }
51061
51062
51063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51064   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51065
51066   arg1 = (Dali::Vector< int > *)jarg1;
51067   {
51068     try {
51069       delete arg1;
51070     } catch (std::out_of_range& e) {
51071       {
51072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51073       };
51074     } catch (std::exception& e) {
51075       {
51076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51077       };
51078     } catch (Dali::DaliException e) {
51079       {
51080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51081       };
51082     } catch (...) {
51083       {
51084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51085       };
51086     }
51087   }
51088
51089 }
51090
51091
51092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51093   void * jresult ;
51094   Dali::Vector< int > *arg1 = 0 ;
51095   Dali::Vector< int > *result = 0 ;
51096
51097   arg1 = (Dali::Vector< int > *)jarg1;
51098   if (!arg1) {
51099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51100     return 0;
51101   }
51102   {
51103     try {
51104       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51105     } catch (std::out_of_range& e) {
51106       {
51107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51108       };
51109     } catch (std::exception& e) {
51110       {
51111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51112       };
51113     } catch (Dali::DaliException e) {
51114       {
51115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51116       };
51117     } catch (...) {
51118       {
51119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51120       };
51121     }
51122   }
51123
51124   jresult = (void *)result;
51125   return jresult;
51126 }
51127
51128
51129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51130   void * jresult ;
51131   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51132   Dali::Vector< int > *arg2 = 0 ;
51133   Dali::Vector< int > *result = 0 ;
51134
51135   arg1 = (Dali::Vector< int > *)jarg1;
51136   arg2 = (Dali::Vector< int > *)jarg2;
51137   if (!arg2) {
51138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51139     return 0;
51140   }
51141   {
51142     try {
51143       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51144     } catch (std::out_of_range& e) {
51145       {
51146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (std::exception& e) {
51149       {
51150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51151       };
51152     } catch (Dali::DaliException e) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51155       };
51156     } catch (...) {
51157       {
51158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51159       };
51160     }
51161   }
51162
51163   jresult = (void *)result;
51164   return jresult;
51165 }
51166
51167
51168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51169   void * jresult ;
51170   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51171   Dali::Vector< int >::Iterator result;
51172
51173   arg1 = (Dali::Vector< int > *)jarg1;
51174   {
51175     try {
51176       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51177     } catch (std::out_of_range& e) {
51178       {
51179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51180       };
51181     } catch (std::exception& e) {
51182       {
51183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51184       };
51185     } catch (Dali::DaliException e) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51188       };
51189     } catch (...) {
51190       {
51191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51192       };
51193     }
51194   }
51195
51196   jresult = (void *)result;
51197   return jresult;
51198 }
51199
51200
51201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51202   void * jresult ;
51203   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51204   Dali::Vector< int >::Iterator result;
51205
51206   arg1 = (Dali::Vector< int > *)jarg1;
51207   {
51208     try {
51209       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51210     } catch (std::out_of_range& e) {
51211       {
51212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51213       };
51214     } catch (std::exception& e) {
51215       {
51216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51217       };
51218     } catch (Dali::DaliException e) {
51219       {
51220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51221       };
51222     } catch (...) {
51223       {
51224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51225       };
51226     }
51227   }
51228
51229   jresult = (void *)result;
51230   return jresult;
51231 }
51232
51233
51234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51235   void * jresult ;
51236   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51237   Dali::Vector< int >::SizeType arg2 ;
51238   Dali::Vector< int >::ItemType *result = 0 ;
51239
51240   arg1 = (Dali::Vector< int > *)jarg1;
51241   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51242   {
51243     try {
51244       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51245     } catch (std::out_of_range& e) {
51246       {
51247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51248       };
51249     } catch (std::exception& e) {
51250       {
51251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51252       };
51253     } catch (Dali::DaliException e) {
51254       {
51255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51256       };
51257     } catch (...) {
51258       {
51259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51260       };
51261     }
51262   }
51263
51264   jresult = (void *)result;
51265   return jresult;
51266 }
51267
51268
51269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51270   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51271   Dali::Vector< int >::ItemType *arg2 = 0 ;
51272   Dali::Vector< int >::ItemType temp2 ;
51273
51274   arg1 = (Dali::Vector< int > *)jarg1;
51275   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51276   arg2 = &temp2;
51277   {
51278     try {
51279       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51280     } catch (std::out_of_range& e) {
51281       {
51282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (std::exception& e) {
51285       {
51286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51287       };
51288     } catch (Dali::DaliException e) {
51289       {
51290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51291       };
51292     } catch (...) {
51293       {
51294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51295       };
51296     }
51297   }
51298
51299 }
51300
51301
51302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51303   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51304   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51305   Dali::Vector< int >::ItemType *arg3 = 0 ;
51306   Dali::Vector< int >::ItemType temp3 ;
51307
51308   arg1 = (Dali::Vector< int > *)jarg1;
51309   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51310   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51311   arg3 = &temp3;
51312   {
51313     try {
51314       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51315     } catch (std::out_of_range& e) {
51316       {
51317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51318       };
51319     } catch (std::exception& e) {
51320       {
51321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51322       };
51323     } catch (Dali::DaliException e) {
51324       {
51325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51326       };
51327     } catch (...) {
51328       {
51329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51330       };
51331     }
51332   }
51333
51334 }
51335
51336
51337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51338   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51339   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51340   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51341   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51342
51343   arg1 = (Dali::Vector< int > *)jarg1;
51344   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51345   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51346   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51347   {
51348     try {
51349       (arg1)->Insert(arg2,arg3,arg4);
51350     } catch (std::out_of_range& e) {
51351       {
51352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51353       };
51354     } catch (std::exception& e) {
51355       {
51356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51357       };
51358     } catch (Dali::DaliException e) {
51359       {
51360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51361       };
51362     } catch (...) {
51363       {
51364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51365       };
51366     }
51367   }
51368
51369 }
51370
51371
51372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51373   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51374   Dali::Vector< int >::SizeType arg2 ;
51375
51376   arg1 = (Dali::Vector< int > *)jarg1;
51377   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51378   {
51379     try {
51380       (arg1)->Reserve(arg2);
51381     } catch (std::out_of_range& e) {
51382       {
51383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51384       };
51385     } catch (std::exception& e) {
51386       {
51387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51388       };
51389     } catch (Dali::DaliException e) {
51390       {
51391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51392       };
51393     } catch (...) {
51394       {
51395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51396       };
51397     }
51398   }
51399
51400 }
51401
51402
51403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51404   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51405   Dali::Vector< int >::SizeType arg2 ;
51406
51407   arg1 = (Dali::Vector< int > *)jarg1;
51408   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51409   {
51410     try {
51411       (arg1)->Resize(arg2);
51412     } catch (std::out_of_range& e) {
51413       {
51414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51415       };
51416     } catch (std::exception& e) {
51417       {
51418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51419       };
51420     } catch (Dali::DaliException e) {
51421       {
51422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51423       };
51424     } catch (...) {
51425       {
51426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51427       };
51428     }
51429   }
51430
51431 }
51432
51433
51434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51435   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51436   Dali::Vector< int >::SizeType arg2 ;
51437   Dali::Vector< int >::ItemType *arg3 = 0 ;
51438   Dali::Vector< int >::ItemType temp3 ;
51439
51440   arg1 = (Dali::Vector< int > *)jarg1;
51441   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51442   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51443   arg3 = &temp3;
51444   {
51445     try {
51446       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51447     } catch (std::out_of_range& e) {
51448       {
51449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51450       };
51451     } catch (std::exception& e) {
51452       {
51453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51454       };
51455     } catch (Dali::DaliException e) {
51456       {
51457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51458       };
51459     } catch (...) {
51460       {
51461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51462       };
51463     }
51464   }
51465
51466 }
51467
51468
51469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51470   void * jresult ;
51471   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51472   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51473   Dali::Vector< int >::Iterator result;
51474
51475   arg1 = (Dali::Vector< int > *)jarg1;
51476   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51477   {
51478     try {
51479       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51480     } catch (std::out_of_range& e) {
51481       {
51482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51483       };
51484     } catch (std::exception& e) {
51485       {
51486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51487       };
51488     } catch (Dali::DaliException e) {
51489       {
51490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51491       };
51492     } catch (...) {
51493       {
51494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51495       };
51496     }
51497   }
51498
51499   jresult = (void *)result;
51500   return jresult;
51501 }
51502
51503
51504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51505   void * jresult ;
51506   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51507   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51508   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51509   Dali::Vector< int >::Iterator result;
51510
51511   arg1 = (Dali::Vector< int > *)jarg1;
51512   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51513   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51514   {
51515     try {
51516       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51517     } catch (std::out_of_range& e) {
51518       {
51519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51520       };
51521     } catch (std::exception& e) {
51522       {
51523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (Dali::DaliException e) {
51526       {
51527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51528       };
51529     } catch (...) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51532       };
51533     }
51534   }
51535
51536   jresult = (void *)result;
51537   return jresult;
51538 }
51539
51540
51541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51542   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51543   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51544
51545   arg1 = (Dali::Vector< int > *)jarg1;
51546   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51547   {
51548     try {
51549       (arg1)->Remove(arg2);
51550     } catch (std::out_of_range& e) {
51551       {
51552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51553       };
51554     } catch (std::exception& e) {
51555       {
51556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51557       };
51558     } catch (Dali::DaliException e) {
51559       {
51560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51561       };
51562     } catch (...) {
51563       {
51564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51565       };
51566     }
51567   }
51568
51569 }
51570
51571
51572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51573   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51574   Dali::Vector< int > *arg2 = 0 ;
51575
51576   arg1 = (Dali::Vector< int > *)jarg1;
51577   arg2 = (Dali::Vector< int > *)jarg2;
51578   if (!arg2) {
51579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51580     return ;
51581   }
51582   {
51583     try {
51584       (arg1)->Swap(*arg2);
51585     } catch (std::out_of_range& e) {
51586       {
51587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51588       };
51589     } catch (std::exception& e) {
51590       {
51591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51592       };
51593     } catch (Dali::DaliException e) {
51594       {
51595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51596       };
51597     } catch (...) {
51598       {
51599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51600       };
51601     }
51602   }
51603
51604 }
51605
51606
51607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51608   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51609
51610   arg1 = (Dali::Vector< int > *)jarg1;
51611   {
51612     try {
51613       (arg1)->Clear();
51614     } catch (std::out_of_range& e) {
51615       {
51616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51617       };
51618     } catch (std::exception& e) {
51619       {
51620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51621       };
51622     } catch (Dali::DaliException e) {
51623       {
51624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51625       };
51626     } catch (...) {
51627       {
51628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51629       };
51630     }
51631   }
51632
51633 }
51634
51635
51636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51637   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51638
51639   arg1 = (Dali::Vector< int > *)jarg1;
51640   {
51641     try {
51642       (arg1)->Release();
51643     } catch (std::out_of_range& e) {
51644       {
51645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51646       };
51647     } catch (std::exception& e) {
51648       {
51649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51650       };
51651     } catch (Dali::DaliException e) {
51652       {
51653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51654       };
51655     } catch (...) {
51656       {
51657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51658       };
51659     }
51660   }
51661
51662 }
51663
51664
51665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51666   int jresult ;
51667   int result;
51668
51669   result = (int)Dali::Vector< float >::BaseType;
51670   jresult = (int)result;
51671   return jresult;
51672 }
51673
51674
51675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51676   void * jresult ;
51677   Dali::Vector< float > *result = 0 ;
51678
51679   {
51680     try {
51681       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51682     } catch (std::out_of_range& e) {
51683       {
51684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51685       };
51686     } catch (std::exception& e) {
51687       {
51688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51689       };
51690     } catch (Dali::DaliException e) {
51691       {
51692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51693       };
51694     } catch (...) {
51695       {
51696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51697       };
51698     }
51699   }
51700
51701   jresult = (void *)result;
51702   return jresult;
51703 }
51704
51705
51706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51707   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51708
51709   arg1 = (Dali::Vector< float > *)jarg1;
51710   {
51711     try {
51712       delete arg1;
51713     } catch (std::out_of_range& e) {
51714       {
51715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51716       };
51717     } catch (std::exception& e) {
51718       {
51719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51720       };
51721     } catch (Dali::DaliException e) {
51722       {
51723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51724       };
51725     } catch (...) {
51726       {
51727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51728       };
51729     }
51730   }
51731
51732 }
51733
51734
51735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51736   void * jresult ;
51737   Dali::Vector< float > *arg1 = 0 ;
51738   Dali::Vector< float > *result = 0 ;
51739
51740   arg1 = (Dali::Vector< float > *)jarg1;
51741   if (!arg1) {
51742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51743     return 0;
51744   }
51745   {
51746     try {
51747       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51748     } catch (std::out_of_range& e) {
51749       {
51750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51751       };
51752     } catch (std::exception& e) {
51753       {
51754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51755       };
51756     } catch (Dali::DaliException e) {
51757       {
51758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51759       };
51760     } catch (...) {
51761       {
51762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51763       };
51764     }
51765   }
51766
51767   jresult = (void *)result;
51768   return jresult;
51769 }
51770
51771
51772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51773   void * jresult ;
51774   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51775   Dali::Vector< float > *arg2 = 0 ;
51776   Dali::Vector< float > *result = 0 ;
51777
51778   arg1 = (Dali::Vector< float > *)jarg1;
51779   arg2 = (Dali::Vector< float > *)jarg2;
51780   if (!arg2) {
51781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51782     return 0;
51783   }
51784   {
51785     try {
51786       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51787     } catch (std::out_of_range& e) {
51788       {
51789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51790       };
51791     } catch (std::exception& e) {
51792       {
51793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51794       };
51795     } catch (Dali::DaliException e) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51798       };
51799     } catch (...) {
51800       {
51801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51802       };
51803     }
51804   }
51805
51806   jresult = (void *)result;
51807   return jresult;
51808 }
51809
51810
51811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51812   void * jresult ;
51813   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51814   Dali::Vector< float >::Iterator result;
51815
51816   arg1 = (Dali::Vector< float > *)jarg1;
51817   {
51818     try {
51819       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51820     } catch (std::out_of_range& e) {
51821       {
51822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (std::exception& e) {
51825       {
51826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51827       };
51828     } catch (Dali::DaliException e) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51831       };
51832     } catch (...) {
51833       {
51834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51835       };
51836     }
51837   }
51838
51839   jresult = (void *)result;
51840   return jresult;
51841 }
51842
51843
51844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51845   void * jresult ;
51846   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51847   Dali::Vector< float >::Iterator result;
51848
51849   arg1 = (Dali::Vector< float > *)jarg1;
51850   {
51851     try {
51852       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51853     } catch (std::out_of_range& e) {
51854       {
51855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51856       };
51857     } catch (std::exception& e) {
51858       {
51859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51860       };
51861     } catch (Dali::DaliException e) {
51862       {
51863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51864       };
51865     } catch (...) {
51866       {
51867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51868       };
51869     }
51870   }
51871
51872   jresult = (void *)result;
51873   return jresult;
51874 }
51875
51876
51877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51878   void * jresult ;
51879   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51880   Dali::Vector< float >::SizeType arg2 ;
51881   Dali::Vector< float >::ItemType *result = 0 ;
51882
51883   arg1 = (Dali::Vector< float > *)jarg1;
51884   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51885   {
51886     try {
51887       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51888     } catch (std::out_of_range& e) {
51889       {
51890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51891       };
51892     } catch (std::exception& e) {
51893       {
51894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51895       };
51896     } catch (Dali::DaliException e) {
51897       {
51898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51899       };
51900     } catch (...) {
51901       {
51902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51903       };
51904     }
51905   }
51906
51907   jresult = (void *)result;
51908   return jresult;
51909 }
51910
51911
51912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51913   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51914   Dali::Vector< float >::ItemType *arg2 = 0 ;
51915   Dali::Vector< float >::ItemType temp2 ;
51916
51917   arg1 = (Dali::Vector< float > *)jarg1;
51918   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51919   arg2 = &temp2;
51920   {
51921     try {
51922       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51923     } catch (std::out_of_range& e) {
51924       {
51925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51926       };
51927     } catch (std::exception& e) {
51928       {
51929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51930       };
51931     } catch (Dali::DaliException e) {
51932       {
51933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51934       };
51935     } catch (...) {
51936       {
51937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51938       };
51939     }
51940   }
51941
51942 }
51943
51944
51945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51946   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51947   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51948   Dali::Vector< float >::ItemType *arg3 = 0 ;
51949   Dali::Vector< float >::ItemType temp3 ;
51950
51951   arg1 = (Dali::Vector< float > *)jarg1;
51952   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51953   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51954   arg3 = &temp3;
51955   {
51956     try {
51957       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51958     } catch (std::out_of_range& e) {
51959       {
51960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51961       };
51962     } catch (std::exception& e) {
51963       {
51964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51965       };
51966     } catch (Dali::DaliException e) {
51967       {
51968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51969       };
51970     } catch (...) {
51971       {
51972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51973       };
51974     }
51975   }
51976
51977 }
51978
51979
51980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51981   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51982   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51983   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51984   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51985
51986   arg1 = (Dali::Vector< float > *)jarg1;
51987   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51988   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51989   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51990   {
51991     try {
51992       (arg1)->Insert(arg2,arg3,arg4);
51993     } catch (std::out_of_range& e) {
51994       {
51995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (std::exception& e) {
51998       {
51999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52000       };
52001     } catch (Dali::DaliException e) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52004       };
52005     } catch (...) {
52006       {
52007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52008       };
52009     }
52010   }
52011
52012 }
52013
52014
52015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52016   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52017   Dali::Vector< float >::SizeType arg2 ;
52018
52019   arg1 = (Dali::Vector< float > *)jarg1;
52020   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52021   {
52022     try {
52023       (arg1)->Reserve(arg2);
52024     } catch (std::out_of_range& e) {
52025       {
52026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52027       };
52028     } catch (std::exception& e) {
52029       {
52030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52031       };
52032     } catch (Dali::DaliException e) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52035       };
52036     } catch (...) {
52037       {
52038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52039       };
52040     }
52041   }
52042
52043 }
52044
52045 //// ========================= end of part 2 =============================
52046
52047 //// ========================== start part 3 ===============================
52048
52049
52050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52051   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52052   Dali::Vector< float >::SizeType arg2 ;
52053
52054   arg1 = (Dali::Vector< float > *)jarg1;
52055   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52056   {
52057     try {
52058       (arg1)->Resize(arg2);
52059     } catch (std::out_of_range& e) {
52060       {
52061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52062       };
52063     } catch (std::exception& e) {
52064       {
52065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52066       };
52067     } catch (Dali::DaliException e) {
52068       {
52069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52070       };
52071     } catch (...) {
52072       {
52073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52074       };
52075     }
52076   }
52077
52078 }
52079
52080
52081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52082   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52083   Dali::Vector< float >::SizeType arg2 ;
52084   Dali::Vector< float >::ItemType *arg3 = 0 ;
52085   Dali::Vector< float >::ItemType temp3 ;
52086
52087   arg1 = (Dali::Vector< float > *)jarg1;
52088   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52089   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52090   arg3 = &temp3;
52091   {
52092     try {
52093       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52094     } catch (std::out_of_range& e) {
52095       {
52096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52097       };
52098     } catch (std::exception& e) {
52099       {
52100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52101       };
52102     } catch (Dali::DaliException e) {
52103       {
52104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52105       };
52106     } catch (...) {
52107       {
52108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52109       };
52110     }
52111   }
52112
52113 }
52114
52115
52116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52117   void * jresult ;
52118   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52119   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52120   Dali::Vector< float >::Iterator result;
52121
52122   arg1 = (Dali::Vector< float > *)jarg1;
52123   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52124   {
52125     try {
52126       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52127     } catch (std::out_of_range& e) {
52128       {
52129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52130       };
52131     } catch (std::exception& e) {
52132       {
52133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52134       };
52135     } catch (Dali::DaliException e) {
52136       {
52137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52138       };
52139     } catch (...) {
52140       {
52141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52142       };
52143     }
52144   }
52145
52146   jresult = (void *)result;
52147   return jresult;
52148 }
52149
52150
52151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52152   void * jresult ;
52153   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52154   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52155   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52156   Dali::Vector< float >::Iterator result;
52157
52158   arg1 = (Dali::Vector< float > *)jarg1;
52159   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52160   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52161   {
52162     try {
52163       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52164     } catch (std::out_of_range& e) {
52165       {
52166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52167       };
52168     } catch (std::exception& e) {
52169       {
52170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52171       };
52172     } catch (Dali::DaliException e) {
52173       {
52174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52175       };
52176     } catch (...) {
52177       {
52178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52179       };
52180     }
52181   }
52182
52183   jresult = (void *)result;
52184   return jresult;
52185 }
52186
52187
52188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52189   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52190   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52191
52192   arg1 = (Dali::Vector< float > *)jarg1;
52193   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52194   {
52195     try {
52196       (arg1)->Remove(arg2);
52197     } catch (std::out_of_range& e) {
52198       {
52199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52200       };
52201     } catch (std::exception& e) {
52202       {
52203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52204       };
52205     } catch (Dali::DaliException e) {
52206       {
52207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52208       };
52209     } catch (...) {
52210       {
52211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52212       };
52213     }
52214   }
52215
52216 }
52217
52218
52219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52220   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52221   Dali::Vector< float > *arg2 = 0 ;
52222
52223   arg1 = (Dali::Vector< float > *)jarg1;
52224   arg2 = (Dali::Vector< float > *)jarg2;
52225   if (!arg2) {
52226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52227     return ;
52228   }
52229   {
52230     try {
52231       (arg1)->Swap(*arg2);
52232     } catch (std::out_of_range& e) {
52233       {
52234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52235       };
52236     } catch (std::exception& e) {
52237       {
52238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52239       };
52240     } catch (Dali::DaliException e) {
52241       {
52242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52243       };
52244     } catch (...) {
52245       {
52246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52247       };
52248     }
52249   }
52250
52251 }
52252
52253
52254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52255   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52256
52257   arg1 = (Dali::Vector< float > *)jarg1;
52258   {
52259     try {
52260       (arg1)->Clear();
52261     } catch (std::out_of_range& e) {
52262       {
52263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52264       };
52265     } catch (std::exception& e) {
52266       {
52267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52268       };
52269     } catch (Dali::DaliException e) {
52270       {
52271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52272       };
52273     } catch (...) {
52274       {
52275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52276       };
52277     }
52278   }
52279
52280 }
52281
52282
52283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52284   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52285
52286   arg1 = (Dali::Vector< float > *)jarg1;
52287   {
52288     try {
52289       (arg1)->Release();
52290     } catch (std::out_of_range& e) {
52291       {
52292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52293       };
52294     } catch (std::exception& e) {
52295       {
52296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52297       };
52298     } catch (Dali::DaliException e) {
52299       {
52300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52301       };
52302     } catch (...) {
52303       {
52304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52305       };
52306     }
52307   }
52308
52309 }
52310
52311
52312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52313   int jresult ;
52314   int result;
52315
52316   result = (int)Dali::Vector< unsigned char >::BaseType;
52317   jresult = (int)result;
52318   return jresult;
52319 }
52320
52321
52322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52323   void * jresult ;
52324   Dali::Vector< unsigned char > *result = 0 ;
52325
52326   {
52327     try {
52328       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52329     } catch (std::out_of_range& e) {
52330       {
52331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (std::exception& e) {
52334       {
52335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52336       };
52337     } catch (Dali::DaliException e) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52340       };
52341     } catch (...) {
52342       {
52343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52344       };
52345     }
52346   }
52347
52348   jresult = (void *)result;
52349   return jresult;
52350 }
52351
52352
52353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52354   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52355
52356   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52357   {
52358     try {
52359       delete arg1;
52360     } catch (std::out_of_range& e) {
52361       {
52362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52363       };
52364     } catch (std::exception& e) {
52365       {
52366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52367       };
52368     } catch (Dali::DaliException e) {
52369       {
52370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52371       };
52372     } catch (...) {
52373       {
52374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52375       };
52376     }
52377   }
52378
52379 }
52380
52381
52382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52383   void * jresult ;
52384   Dali::Vector< unsigned char > *arg1 = 0 ;
52385   Dali::Vector< unsigned char > *result = 0 ;
52386
52387   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52388   if (!arg1) {
52389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52390     return 0;
52391   }
52392   {
52393     try {
52394       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52395     } catch (std::out_of_range& e) {
52396       {
52397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52398       };
52399     } catch (std::exception& e) {
52400       {
52401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52402       };
52403     } catch (Dali::DaliException e) {
52404       {
52405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52406       };
52407     } catch (...) {
52408       {
52409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52410       };
52411     }
52412   }
52413
52414   jresult = (void *)result;
52415   return jresult;
52416 }
52417
52418
52419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52420   void * jresult ;
52421   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52422   Dali::Vector< unsigned char > *arg2 = 0 ;
52423   Dali::Vector< unsigned char > *result = 0 ;
52424
52425   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52426   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52427   if (!arg2) {
52428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52429     return 0;
52430   }
52431   {
52432     try {
52433       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52434     } catch (std::out_of_range& e) {
52435       {
52436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52437       };
52438     } catch (std::exception& e) {
52439       {
52440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (Dali::DaliException e) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52445       };
52446     } catch (...) {
52447       {
52448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52449       };
52450     }
52451   }
52452
52453   jresult = (void *)result;
52454   return jresult;
52455 }
52456
52457
52458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52459   void * jresult ;
52460   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52461   Dali::Vector< unsigned char >::Iterator result;
52462
52463   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52464   {
52465     try {
52466       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52467     } catch (std::out_of_range& e) {
52468       {
52469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52470       };
52471     } catch (std::exception& e) {
52472       {
52473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52474       };
52475     } catch (Dali::DaliException e) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52478       };
52479     } catch (...) {
52480       {
52481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52482       };
52483     }
52484   }
52485
52486   jresult = (void *)result;
52487   return jresult;
52488 }
52489
52490
52491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52492   void * jresult ;
52493   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52494   Dali::Vector< unsigned char >::Iterator result;
52495
52496   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52497   {
52498     try {
52499       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52500     } catch (std::out_of_range& e) {
52501       {
52502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52503       };
52504     } catch (std::exception& e) {
52505       {
52506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (Dali::DaliException e) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52511       };
52512     } catch (...) {
52513       {
52514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52515       };
52516     }
52517   }
52518
52519   jresult = (void *)result;
52520   return jresult;
52521 }
52522
52523
52524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52525   void * jresult ;
52526   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52527   Dali::Vector< unsigned char >::SizeType arg2 ;
52528   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52529
52530   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52531   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52532   {
52533     try {
52534       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52535     } catch (std::out_of_range& e) {
52536       {
52537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52538       };
52539     } catch (std::exception& e) {
52540       {
52541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52542       };
52543     } catch (Dali::DaliException e) {
52544       {
52545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52546       };
52547     } catch (...) {
52548       {
52549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52550       };
52551     }
52552   }
52553
52554   jresult = (void *)result;
52555   return jresult;
52556 }
52557
52558
52559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52560   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52561   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52562   Dali::Vector< unsigned char >::ItemType temp2 ;
52563
52564   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52565   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52566   arg2 = &temp2;
52567   {
52568     try {
52569       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52570     } catch (std::out_of_range& e) {
52571       {
52572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52573       };
52574     } catch (std::exception& e) {
52575       {
52576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52577       };
52578     } catch (Dali::DaliException e) {
52579       {
52580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52581       };
52582     } catch (...) {
52583       {
52584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52585       };
52586     }
52587   }
52588
52589 }
52590
52591
52592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52593   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52594   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52595   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52596   Dali::Vector< unsigned char >::ItemType temp3 ;
52597
52598   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52599   arg2 = jarg2;
52600   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52601   arg3 = &temp3;
52602   {
52603     try {
52604       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52605     } catch (std::out_of_range& e) {
52606       {
52607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52608       };
52609     } catch (std::exception& e) {
52610       {
52611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52612       };
52613     } catch (Dali::DaliException e) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52616       };
52617     } catch (...) {
52618       {
52619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52620       };
52621     }
52622   }
52623
52624
52625
52626 }
52627
52628
52629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52630   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52631   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52632   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52633   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52634
52635   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52636   arg2 = jarg2;
52637   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52638   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52639   {
52640     try {
52641       (arg1)->Insert(arg2,arg3,arg4);
52642     } catch (std::out_of_range& e) {
52643       {
52644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52645       };
52646     } catch (std::exception& e) {
52647       {
52648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52649       };
52650     } catch (Dali::DaliException e) {
52651       {
52652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52653       };
52654     } catch (...) {
52655       {
52656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52657       };
52658     }
52659   }
52660
52661
52662
52663 }
52664
52665
52666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52667   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52668   Dali::Vector< unsigned char >::SizeType arg2 ;
52669
52670   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52671   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52672   {
52673     try {
52674       (arg1)->Reserve(arg2);
52675     } catch (std::out_of_range& e) {
52676       {
52677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (std::exception& e) {
52680       {
52681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52682       };
52683     } catch (Dali::DaliException e) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52686       };
52687     } catch (...) {
52688       {
52689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52690       };
52691     }
52692   }
52693
52694 }
52695
52696
52697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52698   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52699   Dali::Vector< unsigned char >::SizeType arg2 ;
52700
52701   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52702   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52703   {
52704     try {
52705       (arg1)->Resize(arg2);
52706     } catch (std::out_of_range& e) {
52707       {
52708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52709       };
52710     } catch (std::exception& e) {
52711       {
52712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52713       };
52714     } catch (Dali::DaliException e) {
52715       {
52716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52717       };
52718     } catch (...) {
52719       {
52720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52721       };
52722     }
52723   }
52724
52725 }
52726
52727
52728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52729   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52730   Dali::Vector< unsigned char >::SizeType arg2 ;
52731   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52732   Dali::Vector< unsigned char >::ItemType temp3 ;
52733
52734   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52735   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52736   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52737   arg3 = &temp3;
52738   {
52739     try {
52740       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52741     } catch (std::out_of_range& e) {
52742       {
52743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52744       };
52745     } catch (std::exception& e) {
52746       {
52747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52748       };
52749     } catch (Dali::DaliException e) {
52750       {
52751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52752       };
52753     } catch (...) {
52754       {
52755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52756       };
52757     }
52758   }
52759
52760 }
52761
52762
52763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52764   void * jresult ;
52765   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52766   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52767   Dali::Vector< unsigned char >::Iterator result;
52768
52769   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52770   arg2 = jarg2;
52771   {
52772     try {
52773       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52774     } catch (std::out_of_range& e) {
52775       {
52776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52777       };
52778     } catch (std::exception& e) {
52779       {
52780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52781       };
52782     } catch (Dali::DaliException e) {
52783       {
52784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52785       };
52786     } catch (...) {
52787       {
52788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52789       };
52790     }
52791   }
52792
52793   jresult = (void *)result;
52794
52795
52796   return jresult;
52797 }
52798
52799
52800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52801   void * jresult ;
52802   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52803   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52804   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52805   Dali::Vector< unsigned char >::Iterator result;
52806
52807   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52808   arg2 = jarg2;
52809   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52810   {
52811     try {
52812       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52813     } catch (std::out_of_range& e) {
52814       {
52815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52816       };
52817     } catch (std::exception& e) {
52818       {
52819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (Dali::DaliException e) {
52822       {
52823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52824       };
52825     } catch (...) {
52826       {
52827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52828       };
52829     }
52830   }
52831
52832   jresult = (void *)result;
52833
52834
52835   return jresult;
52836 }
52837
52838
52839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52840   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52841   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52842
52843   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52844   arg2 = jarg2;
52845   {
52846     try {
52847       (arg1)->Remove(arg2);
52848     } catch (std::out_of_range& e) {
52849       {
52850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52851       };
52852     } catch (std::exception& e) {
52853       {
52854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52855       };
52856     } catch (Dali::DaliException e) {
52857       {
52858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52859       };
52860     } catch (...) {
52861       {
52862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52863       };
52864     }
52865   }
52866
52867
52868
52869 }
52870
52871
52872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52873   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52874   Dali::Vector< unsigned char > *arg2 = 0 ;
52875
52876   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52877   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52878   if (!arg2) {
52879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52880     return ;
52881   }
52882   {
52883     try {
52884       (arg1)->Swap(*arg2);
52885     } catch (std::out_of_range& e) {
52886       {
52887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52888       };
52889     } catch (std::exception& e) {
52890       {
52891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52892       };
52893     } catch (Dali::DaliException e) {
52894       {
52895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52896       };
52897     } catch (...) {
52898       {
52899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52900       };
52901     }
52902   }
52903
52904 }
52905
52906
52907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52908   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52909
52910   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52911   {
52912     try {
52913       (arg1)->Clear();
52914     } catch (std::out_of_range& e) {
52915       {
52916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52917       };
52918     } catch (std::exception& e) {
52919       {
52920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52921       };
52922     } catch (Dali::DaliException e) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52925       };
52926     } catch (...) {
52927       {
52928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52929       };
52930     }
52931   }
52932
52933 }
52934
52935
52936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52937   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52938
52939   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52940   {
52941     try {
52942       (arg1)->Release();
52943     } catch (std::out_of_range& e) {
52944       {
52945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52946       };
52947     } catch (std::exception& e) {
52948       {
52949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52950       };
52951     } catch (Dali::DaliException e) {
52952       {
52953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52954       };
52955     } catch (...) {
52956       {
52957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52958       };
52959     }
52960   }
52961
52962 }
52963
52964
52965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52966   int jresult ;
52967   int result;
52968
52969   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52970   jresult = (int)result;
52971   return jresult;
52972 }
52973
52974
52975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52976   void * jresult ;
52977   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52978
52979   {
52980     try {
52981       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52982     } catch (std::out_of_range& e) {
52983       {
52984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52985       };
52986     } catch (std::exception& e) {
52987       {
52988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52989       };
52990     } catch (Dali::DaliException e) {
52991       {
52992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52993       };
52994     } catch (...) {
52995       {
52996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52997       };
52998     }
52999   }
53000
53001   jresult = (void *)result;
53002   return jresult;
53003 }
53004
53005
53006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53007   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53008
53009   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53010   {
53011     try {
53012       delete arg1;
53013     } catch (std::out_of_range& e) {
53014       {
53015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53016       };
53017     } catch (std::exception& e) {
53018       {
53019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53020       };
53021     } catch (Dali::DaliException e) {
53022       {
53023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53024       };
53025     } catch (...) {
53026       {
53027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53028       };
53029     }
53030   }
53031
53032 }
53033
53034
53035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53036   void * jresult ;
53037   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53038   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53039
53040   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53041   if (!arg1) {
53042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53043     return 0;
53044   }
53045   {
53046     try {
53047       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53048     } catch (std::out_of_range& e) {
53049       {
53050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53051       };
53052     } catch (std::exception& e) {
53053       {
53054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53055       };
53056     } catch (Dali::DaliException e) {
53057       {
53058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53059       };
53060     } catch (...) {
53061       {
53062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53063       };
53064     }
53065   }
53066
53067   jresult = (void *)result;
53068   return jresult;
53069 }
53070
53071
53072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53073   void * jresult ;
53074   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53075   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53076   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53077
53078   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53079   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53080   if (!arg2) {
53081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53082     return 0;
53083   }
53084   {
53085     try {
53086       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53087     } catch (std::out_of_range& e) {
53088       {
53089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53090       };
53091     } catch (std::exception& e) {
53092       {
53093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53094       };
53095     } catch (Dali::DaliException e) {
53096       {
53097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53098       };
53099     } catch (...) {
53100       {
53101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53102       };
53103     }
53104   }
53105
53106   jresult = (void *)result;
53107   return jresult;
53108 }
53109
53110
53111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53112   void * jresult ;
53113   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53114   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53115
53116   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53117   {
53118     try {
53119       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53120     } catch (std::out_of_range& e) {
53121       {
53122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53123       };
53124     } catch (std::exception& e) {
53125       {
53126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53127       };
53128     } catch (Dali::DaliException e) {
53129       {
53130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53131       };
53132     } catch (...) {
53133       {
53134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53135       };
53136     }
53137   }
53138
53139   jresult = (void *)result;
53140   return jresult;
53141 }
53142
53143
53144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53145   void * jresult ;
53146   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53147   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53148
53149   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53150   {
53151     try {
53152       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53153     } catch (std::out_of_range& e) {
53154       {
53155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (std::exception& e) {
53158       {
53159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53160       };
53161     } catch (Dali::DaliException e) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53164       };
53165     } catch (...) {
53166       {
53167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53168       };
53169     }
53170   }
53171
53172   jresult = (void *)result;
53173   return jresult;
53174 }
53175
53176
53177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53178   void * jresult ;
53179   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53180   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53181   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53182
53183   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53184   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53185   {
53186     try {
53187       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53188     } catch (std::out_of_range& e) {
53189       {
53190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53191       };
53192     } catch (std::exception& e) {
53193       {
53194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53195       };
53196     } catch (Dali::DaliException e) {
53197       {
53198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53199       };
53200     } catch (...) {
53201       {
53202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53203       };
53204     }
53205   }
53206
53207   jresult = (void *)result;
53208   return jresult;
53209 }
53210
53211
53212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53213   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53214   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53215
53216   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53217   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53218   if (!arg2) {
53219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53220     return ;
53221   }
53222   {
53223     try {
53224       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53225     } catch (std::out_of_range& e) {
53226       {
53227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53228       };
53229     } catch (std::exception& e) {
53230       {
53231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53232       };
53233     } catch (Dali::DaliException e) {
53234       {
53235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53236       };
53237     } catch (...) {
53238       {
53239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53240       };
53241     }
53242   }
53243
53244 }
53245
53246
53247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53248   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53249   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53250   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53251
53252   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53253   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53254   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53255   if (!arg3) {
53256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53257     return ;
53258   }
53259   {
53260     try {
53261       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53262     } catch (std::out_of_range& e) {
53263       {
53264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53265       };
53266     } catch (std::exception& e) {
53267       {
53268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53269       };
53270     } catch (Dali::DaliException e) {
53271       {
53272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53273       };
53274     } catch (...) {
53275       {
53276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53277       };
53278     }
53279   }
53280
53281 }
53282
53283
53284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53285   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53286   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53287   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53288   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53289
53290   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53291   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53292   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53293   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53294   {
53295     try {
53296       (arg1)->Insert(arg2,arg3,arg4);
53297     } catch (std::out_of_range& e) {
53298       {
53299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53300       };
53301     } catch (std::exception& e) {
53302       {
53303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53304       };
53305     } catch (Dali::DaliException e) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53308       };
53309     } catch (...) {
53310       {
53311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53312       };
53313     }
53314   }
53315
53316 }
53317
53318
53319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53320   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53321   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53322
53323   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53324   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53325   {
53326     try {
53327       (arg1)->Reserve(arg2);
53328     } catch (std::out_of_range& e) {
53329       {
53330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53331       };
53332     } catch (std::exception& e) {
53333       {
53334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53335       };
53336     } catch (Dali::DaliException e) {
53337       {
53338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53339       };
53340     } catch (...) {
53341       {
53342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53343       };
53344     }
53345   }
53346
53347 }
53348
53349
53350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53351   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53352   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53353
53354   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53355   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53356   {
53357     try {
53358       (arg1)->Resize(arg2);
53359     } catch (std::out_of_range& e) {
53360       {
53361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53362       };
53363     } catch (std::exception& e) {
53364       {
53365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53366       };
53367     } catch (Dali::DaliException e) {
53368       {
53369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53370       };
53371     } catch (...) {
53372       {
53373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53374       };
53375     }
53376   }
53377
53378 }
53379
53380
53381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53382   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53383   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53384   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53385
53386   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53387   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53388   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53389   if (!arg3) {
53390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53391     return ;
53392   }
53393   {
53394     try {
53395       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53396     } catch (std::out_of_range& e) {
53397       {
53398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53399       };
53400     } catch (std::exception& e) {
53401       {
53402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53403       };
53404     } catch (Dali::DaliException e) {
53405       {
53406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53407       };
53408     } catch (...) {
53409       {
53410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53411       };
53412     }
53413   }
53414
53415 }
53416
53417
53418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53419   void * jresult ;
53420   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53421   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53422   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53423
53424   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53425   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53426   {
53427     try {
53428       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53429     } catch (std::out_of_range& e) {
53430       {
53431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53432       };
53433     } catch (std::exception& e) {
53434       {
53435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53436       };
53437     } catch (Dali::DaliException e) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53440       };
53441     } catch (...) {
53442       {
53443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53444       };
53445     }
53446   }
53447
53448   jresult = (void *)result;
53449   return jresult;
53450 }
53451
53452
53453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53454   void * jresult ;
53455   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53456   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53457   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53458   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53459
53460   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53461   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53462   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53463   {
53464     try {
53465       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53466     } catch (std::out_of_range& e) {
53467       {
53468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53469       };
53470     } catch (std::exception& e) {
53471       {
53472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53473       };
53474     } catch (Dali::DaliException e) {
53475       {
53476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53477       };
53478     } catch (...) {
53479       {
53480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53481       };
53482     }
53483   }
53484
53485   jresult = (void *)result;
53486   return jresult;
53487 }
53488
53489
53490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53491   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53492   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53493
53494   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53495   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53496   {
53497     try {
53498       (arg1)->Remove(arg2);
53499     } catch (std::out_of_range& e) {
53500       {
53501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53502       };
53503     } catch (std::exception& e) {
53504       {
53505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53506       };
53507     } catch (Dali::DaliException e) {
53508       {
53509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53510       };
53511     } catch (...) {
53512       {
53513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53514       };
53515     }
53516   }
53517
53518 }
53519
53520
53521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53522   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53523   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53524
53525   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53526   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53527   if (!arg2) {
53528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53529     return ;
53530   }
53531   {
53532     try {
53533       (arg1)->Swap(*arg2);
53534     } catch (std::out_of_range& e) {
53535       {
53536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53537       };
53538     } catch (std::exception& e) {
53539       {
53540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53541       };
53542     } catch (Dali::DaliException e) {
53543       {
53544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53545       };
53546     } catch (...) {
53547       {
53548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53549       };
53550     }
53551   }
53552
53553 }
53554
53555
53556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53557   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53558
53559   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53560   {
53561     try {
53562       (arg1)->Clear();
53563     } catch (std::out_of_range& e) {
53564       {
53565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53566       };
53567     } catch (std::exception& e) {
53568       {
53569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53570       };
53571     } catch (Dali::DaliException e) {
53572       {
53573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53574       };
53575     } catch (...) {
53576       {
53577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53578       };
53579     }
53580   }
53581
53582 }
53583
53584
53585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53586   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53587
53588   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53589   {
53590     try {
53591       (arg1)->Release();
53592     } catch (std::out_of_range& e) {
53593       {
53594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53595       };
53596     } catch (std::exception& e) {
53597       {
53598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53599       };
53600     } catch (Dali::DaliException e) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53603       };
53604     } catch (...) {
53605       {
53606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53607       };
53608     }
53609   }
53610
53611 }
53612
53613
53614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53615   void * jresult ;
53616   Dali::Signal< void () > *result = 0 ;
53617
53618   {
53619     try {
53620       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53621     } catch (std::out_of_range& e) {
53622       {
53623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53624       };
53625     } catch (std::exception& e) {
53626       {
53627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53628       };
53629     } catch (Dali::DaliException e) {
53630       {
53631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53632       };
53633     } catch (...) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53636       };
53637     }
53638   }
53639
53640   jresult = (void *)result;
53641   return jresult;
53642 }
53643
53644
53645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53646   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53647
53648   arg1 = (Dali::Signal< void () > *)jarg1;
53649   {
53650     try {
53651       delete arg1;
53652     } catch (std::out_of_range& e) {
53653       {
53654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53655       };
53656     } catch (std::exception& e) {
53657       {
53658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53659       };
53660     } catch (Dali::DaliException e) {
53661       {
53662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53663       };
53664     } catch (...) {
53665       {
53666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53667       };
53668     }
53669   }
53670
53671 }
53672
53673
53674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53675   unsigned int jresult ;
53676   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53677   bool result;
53678
53679   arg1 = (Dali::Signal< void () > *)jarg1;
53680   {
53681     try {
53682       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53683     } catch (std::out_of_range& e) {
53684       {
53685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53686       };
53687     } catch (std::exception& e) {
53688       {
53689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53690       };
53691     } catch (Dali::DaliException e) {
53692       {
53693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53694       };
53695     } catch (...) {
53696       {
53697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53698       };
53699     }
53700   }
53701
53702   jresult = result;
53703   return jresult;
53704 }
53705
53706
53707 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53708   unsigned long jresult ;
53709   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53710   std::size_t result;
53711
53712   arg1 = (Dali::Signal< void () > *)jarg1;
53713   {
53714     try {
53715       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53716     } catch (std::out_of_range& e) {
53717       {
53718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53719       };
53720     } catch (std::exception& e) {
53721       {
53722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53723       };
53724     } catch (Dali::DaliException e) {
53725       {
53726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53727       };
53728     } catch (...) {
53729       {
53730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53731       };
53732     }
53733   }
53734
53735   jresult = (unsigned long)result;
53736   return jresult;
53737 }
53738
53739
53740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53741   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53742   void (*arg2)() = (void (*)()) 0 ;
53743
53744   arg1 = (Dali::Signal< void () > *)jarg1;
53745   arg2 = (void (*)())jarg2;
53746   {
53747     try {
53748       (arg1)->Connect(arg2);
53749     } catch (std::out_of_range& e) {
53750       {
53751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53752       };
53753     } catch (std::exception& e) {
53754       {
53755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53756       };
53757     } catch (Dali::DaliException e) {
53758       {
53759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53760       };
53761     } catch (...) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53764       };
53765     }
53766   }
53767
53768 }
53769
53770
53771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53772   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53773   void (*arg2)() = (void (*)()) 0 ;
53774
53775   arg1 = (Dali::Signal< void () > *)jarg1;
53776   arg2 = (void (*)())jarg2;
53777   {
53778     try {
53779       (arg1)->Disconnect(arg2);
53780     } catch (std::out_of_range& e) {
53781       {
53782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53783       };
53784     } catch (std::exception& e) {
53785       {
53786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53787       };
53788     } catch (Dali::DaliException e) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53791       };
53792     } catch (...) {
53793       {
53794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53795       };
53796     }
53797   }
53798
53799 }
53800
53801
53802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53803   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53804   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53805   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53806
53807   arg1 = (Dali::Signal< void () > *)jarg1;
53808   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53809   arg3 = (Dali::FunctorDelegate *)jarg3;
53810   {
53811     try {
53812       (arg1)->Connect(arg2,arg3);
53813     } catch (std::out_of_range& e) {
53814       {
53815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (std::exception& e) {
53818       {
53819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53820       };
53821     } catch (Dali::DaliException e) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53824       };
53825     } catch (...) {
53826       {
53827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53828       };
53829     }
53830   }
53831
53832 }
53833
53834
53835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53836   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53837
53838   arg1 = (Dali::Signal< void () > *)jarg1;
53839   {
53840     try {
53841       (arg1)->Emit();
53842     } catch (std::out_of_range& e) {
53843       {
53844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53845       };
53846     } catch (std::exception& e) {
53847       {
53848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53849       };
53850     } catch (Dali::DaliException e) {
53851       {
53852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53853       };
53854     } catch (...) {
53855       {
53856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53857       };
53858     }
53859   }
53860
53861 }
53862
53863
53864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53865   unsigned int jresult ;
53866   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53867   bool result;
53868
53869   arg1 = (Dali::Signal< void (float) > *)jarg1;
53870   {
53871     try {
53872       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53873     } catch (std::out_of_range& e) {
53874       {
53875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53876       };
53877     } catch (std::exception& e) {
53878       {
53879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (Dali::DaliException e) {
53882       {
53883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53884       };
53885     } catch (...) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53888       };
53889     }
53890   }
53891
53892   jresult = result;
53893   return jresult;
53894 }
53895
53896
53897 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53898   unsigned long jresult ;
53899   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53900   std::size_t result;
53901
53902   arg1 = (Dali::Signal< void (float) > *)jarg1;
53903   {
53904     try {
53905       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53906     } catch (std::out_of_range& e) {
53907       {
53908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53909       };
53910     } catch (std::exception& e) {
53911       {
53912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53913       };
53914     } catch (Dali::DaliException e) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53917       };
53918     } catch (...) {
53919       {
53920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53921       };
53922     }
53923   }
53924
53925   jresult = (unsigned long)result;
53926   return jresult;
53927 }
53928
53929
53930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53931   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53932   void (*arg2)(float) = (void (*)(float)) 0 ;
53933
53934   arg1 = (Dali::Signal< void (float) > *)jarg1;
53935   arg2 = (void (*)(float))jarg2;
53936   {
53937     try {
53938       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53939     } catch (std::out_of_range& e) {
53940       {
53941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53942       };
53943     } catch (std::exception& e) {
53944       {
53945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53946       };
53947     } catch (Dali::DaliException e) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53950       };
53951     } catch (...) {
53952       {
53953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53954       };
53955     }
53956   }
53957
53958 }
53959
53960
53961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53962   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53963   void (*arg2)(float) = (void (*)(float)) 0 ;
53964
53965   arg1 = (Dali::Signal< void (float) > *)jarg1;
53966   arg2 = (void (*)(float))jarg2;
53967   {
53968     try {
53969       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53970     } catch (std::out_of_range& e) {
53971       {
53972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53973       };
53974     } catch (std::exception& e) {
53975       {
53976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53977       };
53978     } catch (Dali::DaliException e) {
53979       {
53980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53981       };
53982     } catch (...) {
53983       {
53984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53985       };
53986     }
53987   }
53988
53989 }
53990
53991
53992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53993   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53994   float arg2 ;
53995
53996   arg1 = (Dali::Signal< void (float) > *)jarg1;
53997   arg2 = (float)jarg2;
53998   {
53999     try {
54000       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54001     } catch (std::out_of_range& e) {
54002       {
54003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54004       };
54005     } catch (std::exception& e) {
54006       {
54007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54008       };
54009     } catch (Dali::DaliException e) {
54010       {
54011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54012       };
54013     } catch (...) {
54014       {
54015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54016       };
54017     }
54018   }
54019
54020 }
54021
54022
54023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54024   void * jresult ;
54025   Dali::Signal< void (float) > *result = 0 ;
54026
54027   {
54028     try {
54029       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54030     } catch (std::out_of_range& e) {
54031       {
54032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54033       };
54034     } catch (std::exception& e) {
54035       {
54036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54037       };
54038     } catch (Dali::DaliException e) {
54039       {
54040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54041       };
54042     } catch (...) {
54043       {
54044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54045       };
54046     }
54047   }
54048
54049   jresult = (void *)result;
54050   return jresult;
54051 }
54052
54053
54054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54055   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54056
54057   arg1 = (Dali::Signal< void (float) > *)jarg1;
54058   {
54059     try {
54060       delete arg1;
54061     } catch (std::out_of_range& e) {
54062       {
54063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54064       };
54065     } catch (std::exception& e) {
54066       {
54067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54068       };
54069     } catch (Dali::DaliException e) {
54070       {
54071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54072       };
54073     } catch (...) {
54074       {
54075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54076       };
54077     }
54078   }
54079
54080 }
54081
54082
54083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54084   unsigned int jresult ;
54085   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54086   bool result;
54087
54088   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54089   {
54090     try {
54091       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54092     } catch (std::out_of_range& e) {
54093       {
54094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (std::exception& e) {
54097       {
54098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54099       };
54100     } catch (Dali::DaliException e) {
54101       {
54102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54103       };
54104     } catch (...) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54107       };
54108     }
54109   }
54110
54111   jresult = result;
54112   return jresult;
54113 }
54114
54115
54116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54117   unsigned long jresult ;
54118   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54119   std::size_t result;
54120
54121   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54122   {
54123     try {
54124       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54125     } catch (std::out_of_range& e) {
54126       {
54127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54128       };
54129     } catch (std::exception& e) {
54130       {
54131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54132       };
54133     } catch (Dali::DaliException e) {
54134       {
54135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54140       };
54141     }
54142   }
54143
54144   jresult = (unsigned long)result;
54145   return jresult;
54146 }
54147
54148
54149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54150   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54151   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54152
54153   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54154   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54155   {
54156     try {
54157       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54158     } catch (std::out_of_range& e) {
54159       {
54160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54161       };
54162     } catch (std::exception& e) {
54163       {
54164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54165       };
54166     } catch (Dali::DaliException e) {
54167       {
54168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54169       };
54170     } catch (...) {
54171       {
54172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54173       };
54174     }
54175   }
54176
54177 }
54178
54179
54180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54181   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54182   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54183
54184   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54185   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54186   {
54187     try {
54188       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54189     } catch (std::out_of_range& e) {
54190       {
54191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54192       };
54193     } catch (std::exception& e) {
54194       {
54195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54196       };
54197     } catch (Dali::DaliException e) {
54198       {
54199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54200       };
54201     } catch (...) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54204       };
54205     }
54206   }
54207
54208 }
54209
54210
54211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54212   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54213   Dali::BaseHandle arg2 ;
54214   Dali::BaseHandle *argp2 ;
54215
54216   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54217   argp2 = (Dali::BaseHandle *)jarg2;
54218   if (!argp2) {
54219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54220     return ;
54221   }
54222   arg2 = *argp2;
54223   {
54224     try {
54225       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54226     } catch (std::out_of_range& e) {
54227       {
54228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54229       };
54230     } catch (std::exception& e) {
54231       {
54232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54233       };
54234     } catch (Dali::DaliException e) {
54235       {
54236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54237       };
54238     } catch (...) {
54239       {
54240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54241       };
54242     }
54243   }
54244
54245 }
54246
54247
54248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54249   void * jresult ;
54250   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54251
54252   {
54253     try {
54254       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54255     } catch (std::out_of_range& e) {
54256       {
54257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54258       };
54259     } catch (std::exception& e) {
54260       {
54261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54262       };
54263     } catch (Dali::DaliException e) {
54264       {
54265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54266       };
54267     } catch (...) {
54268       {
54269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54270       };
54271     }
54272   }
54273
54274   jresult = (void *)result;
54275   return jresult;
54276 }
54277
54278
54279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54280   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54281
54282   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54283   {
54284     try {
54285       delete arg1;
54286     } catch (std::out_of_range& e) {
54287       {
54288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54289       };
54290     } catch (std::exception& e) {
54291       {
54292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54293       };
54294     } catch (Dali::DaliException e) {
54295       {
54296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54297       };
54298     } catch (...) {
54299       {
54300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54301       };
54302     }
54303   }
54304
54305 }
54306
54307
54308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54309   unsigned int jresult ;
54310   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54311   bool result;
54312
54313   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54314   {
54315     try {
54316       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54317     } catch (std::out_of_range& e) {
54318       {
54319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54320       };
54321     } catch (std::exception& e) {
54322       {
54323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54324       };
54325     } catch (Dali::DaliException e) {
54326       {
54327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54328       };
54329     } catch (...) {
54330       {
54331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54332       };
54333     }
54334   }
54335
54336   jresult = result;
54337   return jresult;
54338 }
54339
54340
54341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54342   unsigned long jresult ;
54343   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54344   std::size_t result;
54345
54346   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54347   {
54348     try {
54349       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54357       };
54358     } catch (Dali::DaliException e) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54361       };
54362     } catch (...) {
54363       {
54364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54365       };
54366     }
54367   }
54368
54369   jresult = (unsigned long)result;
54370   return jresult;
54371 }
54372
54373
54374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54375   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54376   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54377
54378   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54379   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54380   {
54381     try {
54382       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54383     } catch (std::out_of_range& e) {
54384       {
54385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (std::exception& e) {
54388       {
54389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54390       };
54391     } catch (Dali::DaliException e) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54394       };
54395     } catch (...) {
54396       {
54397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54398       };
54399     }
54400   }
54401
54402 }
54403
54404
54405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54406   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54407   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54408
54409   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54410   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54411   {
54412     try {
54413       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54414     } catch (std::out_of_range& e) {
54415       {
54416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54417       };
54418     } catch (std::exception& e) {
54419       {
54420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54421       };
54422     } catch (Dali::DaliException e) {
54423       {
54424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54425       };
54426     } catch (...) {
54427       {
54428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54429       };
54430     }
54431   }
54432
54433 }
54434
54435
54436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54437   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54438   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54439
54440   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54441   arg2 = (Dali::RefObject *)jarg2;
54442   {
54443     try {
54444       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54445     } catch (std::out_of_range& e) {
54446       {
54447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54448       };
54449     } catch (std::exception& e) {
54450       {
54451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54452       };
54453     } catch (Dali::DaliException e) {
54454       {
54455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54456       };
54457     } catch (...) {
54458       {
54459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54460       };
54461     }
54462   }
54463
54464 }
54465
54466
54467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54468   void * jresult ;
54469   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54470
54471   {
54472     try {
54473       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54474     } catch (std::out_of_range& e) {
54475       {
54476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54477       };
54478     } catch (std::exception& e) {
54479       {
54480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (Dali::DaliException e) {
54483       {
54484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54485       };
54486     } catch (...) {
54487       {
54488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54489       };
54490     }
54491   }
54492
54493   jresult = (void *)result;
54494   return jresult;
54495 }
54496
54497
54498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54499   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54500
54501   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54502   {
54503     try {
54504       delete arg1;
54505     } catch (std::out_of_range& e) {
54506       {
54507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54508       };
54509     } catch (std::exception& e) {
54510       {
54511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54512       };
54513     } catch (Dali::DaliException e) {
54514       {
54515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54516       };
54517     } catch (...) {
54518       {
54519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54520       };
54521     }
54522   }
54523
54524 }
54525
54526
54527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54528   unsigned int jresult ;
54529   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54530   bool result;
54531
54532   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54533   {
54534     try {
54535       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54536     } catch (std::out_of_range& e) {
54537       {
54538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54539       };
54540     } catch (std::exception& e) {
54541       {
54542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54543       };
54544     } catch (Dali::DaliException e) {
54545       {
54546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54547       };
54548     } catch (...) {
54549       {
54550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54551       };
54552     }
54553   }
54554
54555   jresult = result;
54556   return jresult;
54557 }
54558
54559
54560 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54561   unsigned long jresult ;
54562   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54563   std::size_t result;
54564
54565   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54566   {
54567     try {
54568       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54569     } catch (std::out_of_range& e) {
54570       {
54571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54572       };
54573     } catch (std::exception& e) {
54574       {
54575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54576       };
54577     } catch (Dali::DaliException e) {
54578       {
54579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54580       };
54581     } catch (...) {
54582       {
54583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54584       };
54585     }
54586   }
54587
54588   jresult = (unsigned long)result;
54589   return jresult;
54590 }
54591
54592
54593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54594   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54595   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54596
54597   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54598   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54599   {
54600     try {
54601       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54602     } catch (std::out_of_range& e) {
54603       {
54604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54605       };
54606     } catch (std::exception& e) {
54607       {
54608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54609       };
54610     } catch (Dali::DaliException e) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54613       };
54614     } catch (...) {
54615       {
54616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54617       };
54618     }
54619   }
54620
54621 }
54622
54623
54624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54625   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54626   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54627
54628   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54629   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54630   {
54631     try {
54632       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54633     } catch (std::out_of_range& e) {
54634       {
54635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54636       };
54637     } catch (std::exception& e) {
54638       {
54639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54640       };
54641     } catch (Dali::DaliException e) {
54642       {
54643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54644       };
54645     } catch (...) {
54646       {
54647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54648       };
54649     }
54650   }
54651
54652 }
54653
54654
54655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54656   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54657   Dali::PropertyNotification *arg2 = 0 ;
54658
54659   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54660   arg2 = (Dali::PropertyNotification *)jarg2;
54661   if (!arg2) {
54662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54663     return ;
54664   }
54665   {
54666     try {
54667       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54668     } catch (std::out_of_range& e) {
54669       {
54670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54671       };
54672     } catch (std::exception& e) {
54673       {
54674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54675       };
54676     } catch (Dali::DaliException e) {
54677       {
54678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54679       };
54680     } catch (...) {
54681       {
54682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54683       };
54684     }
54685   }
54686
54687 }
54688
54689
54690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54691   void * jresult ;
54692   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54693
54694   {
54695     try {
54696       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54697     } catch (std::out_of_range& e) {
54698       {
54699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54700       };
54701     } catch (std::exception& e) {
54702       {
54703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54704       };
54705     } catch (Dali::DaliException e) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54708       };
54709     } catch (...) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54712       };
54713     }
54714   }
54715
54716   jresult = (void *)result;
54717   return jresult;
54718 }
54719
54720
54721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54722   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54723
54724   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54725   {
54726     try {
54727       delete arg1;
54728     } catch (std::out_of_range& e) {
54729       {
54730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54731       };
54732     } catch (std::exception& e) {
54733       {
54734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54735       };
54736     } catch (Dali::DaliException e) {
54737       {
54738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54739       };
54740     } catch (...) {
54741       {
54742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54743       };
54744     }
54745   }
54746
54747 }
54748
54749
54750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54751   unsigned int jresult ;
54752   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54753   bool result;
54754
54755   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54756   {
54757     try {
54758       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54759     } catch (std::out_of_range& e) {
54760       {
54761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54762       };
54763     } catch (std::exception& e) {
54764       {
54765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54766       };
54767     } catch (Dali::DaliException e) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54770       };
54771     } catch (...) {
54772       {
54773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54774       };
54775     }
54776   }
54777
54778   jresult = result;
54779   return jresult;
54780 }
54781
54782
54783 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54784   unsigned long jresult ;
54785   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54786   std::size_t result;
54787
54788   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54789   {
54790     try {
54791       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54792     } catch (std::out_of_range& e) {
54793       {
54794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (std::exception& e) {
54797       {
54798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54799       };
54800     } catch (Dali::DaliException e) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54803       };
54804     } catch (...) {
54805       {
54806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54807       };
54808     }
54809   }
54810
54811   jresult = (unsigned long)result;
54812   return jresult;
54813 }
54814
54815
54816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54817   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54818   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54819
54820   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54821   arg2 = (void (*)(Dali::Image))jarg2;
54822   {
54823     try {
54824       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54825     } catch (std::out_of_range& e) {
54826       {
54827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54828       };
54829     } catch (std::exception& e) {
54830       {
54831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54832       };
54833     } catch (Dali::DaliException e) {
54834       {
54835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54836       };
54837     } catch (...) {
54838       {
54839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54840       };
54841     }
54842   }
54843
54844 }
54845
54846
54847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54848   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54849   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54850
54851   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54852   arg2 = (void (*)(Dali::Image))jarg2;
54853   {
54854     try {
54855       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54856     } catch (std::out_of_range& e) {
54857       {
54858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54859       };
54860     } catch (std::exception& e) {
54861       {
54862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54863       };
54864     } catch (Dali::DaliException e) {
54865       {
54866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54867       };
54868     } catch (...) {
54869       {
54870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54871       };
54872     }
54873   }
54874
54875 }
54876
54877
54878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54879   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54880   Dali::Image arg2 ;
54881   Dali::Image *argp2 ;
54882
54883   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54884   argp2 = (Dali::Image *)jarg2;
54885   if (!argp2) {
54886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54887     return ;
54888   }
54889   arg2 = *argp2;
54890   {
54891     try {
54892       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54893     } catch (std::out_of_range& e) {
54894       {
54895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54896       };
54897     } catch (std::exception& e) {
54898       {
54899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54900       };
54901     } catch (Dali::DaliException e) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54904       };
54905     } catch (...) {
54906       {
54907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54908       };
54909     }
54910   }
54911
54912 }
54913
54914
54915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54916   void * jresult ;
54917   Dali::Signal< void (Dali::Image) > *result = 0 ;
54918
54919   {
54920     try {
54921       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54922     } catch (std::out_of_range& e) {
54923       {
54924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54925       };
54926     } catch (std::exception& e) {
54927       {
54928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54929       };
54930     } catch (Dali::DaliException e) {
54931       {
54932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54933       };
54934     } catch (...) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54937       };
54938     }
54939   }
54940
54941   jresult = (void *)result;
54942   return jresult;
54943 }
54944
54945
54946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54947   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54948
54949   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54950   {
54951     try {
54952       delete arg1;
54953     } catch (std::out_of_range& e) {
54954       {
54955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54956       };
54957     } catch (std::exception& e) {
54958       {
54959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54960       };
54961     } catch (Dali::DaliException e) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54964       };
54965     } catch (...) {
54966       {
54967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54968       };
54969     }
54970   }
54971
54972 }
54973
54974
54975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54976   void * jresult ;
54977   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54978
54979   {
54980     try {
54981       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54982     } catch (std::out_of_range& e) {
54983       {
54984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54985       };
54986     } catch (std::exception& e) {
54987       {
54988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54989       };
54990     } catch (Dali::DaliException e) {
54991       {
54992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54993       };
54994     } catch (...) {
54995       {
54996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54997       };
54998     }
54999   }
55000
55001   jresult = (void *)result;
55002   return jresult;
55003 }
55004
55005
55006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55007   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55008
55009   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55010   {
55011     try {
55012       delete arg1;
55013     } catch (std::out_of_range& e) {
55014       {
55015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55016       };
55017     } catch (std::exception& e) {
55018       {
55019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55020       };
55021     } catch (Dali::DaliException e) {
55022       {
55023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55024       };
55025     } catch (...) {
55026       {
55027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55028       };
55029     }
55030   }
55031
55032 }
55033
55034
55035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55036   unsigned int jresult ;
55037   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55038   bool result;
55039
55040   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55041   {
55042     try {
55043       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);
55044     } catch (std::out_of_range& e) {
55045       {
55046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55047       };
55048     } catch (std::exception& e) {
55049       {
55050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55051       };
55052     } catch (Dali::DaliException e) {
55053       {
55054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55055       };
55056     } catch (...) {
55057       {
55058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55059       };
55060     }
55061   }
55062
55063   jresult = result;
55064   return jresult;
55065 }
55066
55067
55068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55069   unsigned long jresult ;
55070   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55071   std::size_t result;
55072
55073   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55074   {
55075     try {
55076       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);
55077     } catch (std::out_of_range& e) {
55078       {
55079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (std::exception& e) {
55082       {
55083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55084       };
55085     } catch (Dali::DaliException e) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55088       };
55089     } catch (...) {
55090       {
55091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55092       };
55093     }
55094   }
55095
55096   jresult = (unsigned long)result;
55097   return jresult;
55098 }
55099
55100
55101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55102   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55103   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55104
55105   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55106   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55107   {
55108     try {
55109       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55110     } catch (std::out_of_range& e) {
55111       {
55112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55113       };
55114     } catch (std::exception& e) {
55115       {
55116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55117       };
55118     } catch (Dali::DaliException e) {
55119       {
55120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55121       };
55122     } catch (...) {
55123       {
55124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55125       };
55126     }
55127   }
55128
55129 }
55130
55131
55132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55133   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55134   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55135
55136   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55137   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55138   {
55139     try {
55140       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55141     } catch (std::out_of_range& e) {
55142       {
55143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55144       };
55145     } catch (std::exception& e) {
55146       {
55147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55148       };
55149     } catch (Dali::DaliException e) {
55150       {
55151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55152       };
55153     } catch (...) {
55154       {
55155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55156       };
55157     }
55158   }
55159
55160 }
55161
55162
55163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55164   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55165   Dali::Actor arg2 ;
55166   Dali::LongPressGesture *arg3 = 0 ;
55167   Dali::Actor *argp2 ;
55168
55169   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55170   argp2 = (Dali::Actor *)jarg2;
55171   if (!argp2) {
55172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55173     return ;
55174   }
55175   arg2 = *argp2;
55176   arg3 = (Dali::LongPressGesture *)jarg3;
55177   if (!arg3) {
55178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55179     return ;
55180   }
55181   {
55182     try {
55183       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55184     } catch (std::out_of_range& e) {
55185       {
55186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55187       };
55188     } catch (std::exception& e) {
55189       {
55190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55191       };
55192     } catch (Dali::DaliException e) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55195       };
55196     } catch (...) {
55197       {
55198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55199       };
55200     }
55201   }
55202
55203 }
55204
55205
55206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55207   void * jresult ;
55208   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55209
55210   {
55211     try {
55212       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55213     } catch (std::out_of_range& e) {
55214       {
55215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55216       };
55217     } catch (std::exception& e) {
55218       {
55219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55220       };
55221     } catch (Dali::DaliException e) {
55222       {
55223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55224       };
55225     } catch (...) {
55226       {
55227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55228       };
55229     }
55230   }
55231
55232   jresult = (void *)result;
55233   return jresult;
55234 }
55235
55236
55237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55238   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55239
55240   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55241   {
55242     try {
55243       delete arg1;
55244     } catch (std::out_of_range& e) {
55245       {
55246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55247       };
55248     } catch (std::exception& e) {
55249       {
55250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55251       };
55252     } catch (Dali::DaliException e) {
55253       {
55254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55255       };
55256     } catch (...) {
55257       {
55258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55259       };
55260     }
55261   }
55262
55263 }
55264
55265
55266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55267   unsigned int jresult ;
55268   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55269   bool result;
55270
55271   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55272   {
55273     try {
55274       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);
55275     } catch (std::out_of_range& e) {
55276       {
55277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55278       };
55279     } catch (std::exception& e) {
55280       {
55281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55282       };
55283     } catch (Dali::DaliException e) {
55284       {
55285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55286       };
55287     } catch (...) {
55288       {
55289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55290       };
55291     }
55292   }
55293
55294   jresult = result;
55295   return jresult;
55296 }
55297
55298
55299 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55300   unsigned long jresult ;
55301   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55302   std::size_t result;
55303
55304   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55305   {
55306     try {
55307       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);
55308     } catch (std::out_of_range& e) {
55309       {
55310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (std::exception& e) {
55313       {
55314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55315       };
55316     } catch (Dali::DaliException e) {
55317       {
55318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55319       };
55320     } catch (...) {
55321       {
55322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55323       };
55324     }
55325   }
55326
55327   jresult = (unsigned long)result;
55328   return jresult;
55329 }
55330
55331
55332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55333   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55334   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55335
55336   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55337   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55338   {
55339     try {
55340       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55341     } catch (std::out_of_range& e) {
55342       {
55343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55344       };
55345     } catch (std::exception& e) {
55346       {
55347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55348       };
55349     } catch (Dali::DaliException e) {
55350       {
55351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55352       };
55353     } catch (...) {
55354       {
55355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55356       };
55357     }
55358   }
55359
55360 }
55361
55362
55363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55364   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55365   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55366
55367   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55368   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55369   {
55370     try {
55371       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55372     } catch (std::out_of_range& e) {
55373       {
55374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55375       };
55376     } catch (std::exception& e) {
55377       {
55378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55379       };
55380     } catch (Dali::DaliException e) {
55381       {
55382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55383       };
55384     } catch (...) {
55385       {
55386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55387       };
55388     }
55389   }
55390
55391 }
55392
55393
55394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55395   unsigned int jresult ;
55396   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55397   Dali::Actor arg2 ;
55398   Dali::TouchData *arg3 = 0 ;
55399   Dali::Actor *argp2 ;
55400   bool result;
55401
55402   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55403   argp2 = (Dali::Actor *)jarg2;
55404   if (!argp2) {
55405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55406     return 0;
55407   }
55408   arg2 = *argp2;
55409   arg3 = (Dali::TouchData *)jarg3;
55410   if (!arg3) {
55411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55412     return 0;
55413   }
55414   {
55415     try {
55416       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55417     } catch (std::out_of_range& e) {
55418       {
55419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55420       };
55421     } catch (std::exception& e) {
55422       {
55423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55424       };
55425     } catch (Dali::DaliException e) {
55426       {
55427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55428       };
55429     } catch (...) {
55430       {
55431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55432       };
55433     }
55434   }
55435
55436   jresult = result;
55437   return jresult;
55438 }
55439
55440
55441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55442   void * jresult ;
55443   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55444
55445   {
55446     try {
55447       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55448     } catch (std::out_of_range& e) {
55449       {
55450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55451       };
55452     } catch (std::exception& e) {
55453       {
55454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55455       };
55456     } catch (Dali::DaliException e) {
55457       {
55458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55459       };
55460     } catch (...) {
55461       {
55462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55463       };
55464     }
55465   }
55466
55467   jresult = (void *)result;
55468   return jresult;
55469 }
55470
55471
55472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55473   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55474
55475   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55476   {
55477     try {
55478       delete arg1;
55479     } catch (std::out_of_range& e) {
55480       {
55481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55482       };
55483     } catch (std::exception& e) {
55484       {
55485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55486       };
55487     } catch (Dali::DaliException e) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55490       };
55491     } catch (...) {
55492       {
55493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55494       };
55495     }
55496   }
55497
55498 }
55499
55500
55501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55502   unsigned int jresult ;
55503   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55504   bool result;
55505
55506   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55507   {
55508     try {
55509       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);
55510     } catch (std::out_of_range& e) {
55511       {
55512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55513       };
55514     } catch (std::exception& e) {
55515       {
55516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55517       };
55518     } catch (Dali::DaliException e) {
55519       {
55520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55521       };
55522     } catch (...) {
55523       {
55524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55525       };
55526     }
55527   }
55528
55529   jresult = result;
55530   return jresult;
55531 }
55532
55533
55534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55535   unsigned long jresult ;
55536   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55537   std::size_t result;
55538
55539   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55540   {
55541     try {
55542       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);
55543     } catch (std::out_of_range& e) {
55544       {
55545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55546       };
55547     } catch (std::exception& e) {
55548       {
55549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55550       };
55551     } catch (Dali::DaliException e) {
55552       {
55553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55554       };
55555     } catch (...) {
55556       {
55557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55558       };
55559     }
55560   }
55561
55562   jresult = (unsigned long)result;
55563   return jresult;
55564 }
55565
55566
55567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55568   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55569   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55570
55571   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55572   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55573   {
55574     try {
55575       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55576     } catch (std::out_of_range& e) {
55577       {
55578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55579       };
55580     } catch (std::exception& e) {
55581       {
55582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55583       };
55584     } catch (Dali::DaliException e) {
55585       {
55586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55587       };
55588     } catch (...) {
55589       {
55590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55591       };
55592     }
55593   }
55594
55595 }
55596
55597
55598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55599   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55600   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55601
55602   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55603   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55604   {
55605     try {
55606       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55607     } catch (std::out_of_range& e) {
55608       {
55609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55610       };
55611     } catch (std::exception& e) {
55612       {
55613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55614       };
55615     } catch (Dali::DaliException e) {
55616       {
55617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55618       };
55619     } catch (...) {
55620       {
55621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55622       };
55623     }
55624   }
55625
55626 }
55627
55628
55629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55630   unsigned int jresult ;
55631   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55632   Dali::Actor arg2 ;
55633   Dali::HoverEvent *arg3 = 0 ;
55634   Dali::Actor *argp2 ;
55635   bool result;
55636
55637   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55638   argp2 = (Dali::Actor *)jarg2;
55639   if (!argp2) {
55640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55641     return 0;
55642   }
55643   arg2 = *argp2;
55644   arg3 = (Dali::HoverEvent *)jarg3;
55645   if (!arg3) {
55646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55647     return 0;
55648   }
55649   {
55650     try {
55651       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55652     } catch (std::out_of_range& e) {
55653       {
55654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55655       };
55656     } catch (std::exception& e) {
55657       {
55658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55659       };
55660     } catch (Dali::DaliException e) {
55661       {
55662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55663       };
55664     } catch (...) {
55665       {
55666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55667       };
55668     }
55669   }
55670
55671   jresult = result;
55672   return jresult;
55673 }
55674
55675
55676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55677   void * jresult ;
55678   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55679
55680   {
55681     try {
55682       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55683     } catch (std::out_of_range& e) {
55684       {
55685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55686       };
55687     } catch (std::exception& e) {
55688       {
55689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55690       };
55691     } catch (Dali::DaliException e) {
55692       {
55693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55694       };
55695     } catch (...) {
55696       {
55697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55698       };
55699     }
55700   }
55701
55702   jresult = (void *)result;
55703   return jresult;
55704 }
55705
55706
55707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55708   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55709
55710   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55711   {
55712     try {
55713       delete arg1;
55714     } catch (std::out_of_range& e) {
55715       {
55716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55717       };
55718     } catch (std::exception& e) {
55719       {
55720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55721       };
55722     } catch (Dali::DaliException e) {
55723       {
55724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55725       };
55726     } catch (...) {
55727       {
55728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55729       };
55730     }
55731   }
55732
55733 }
55734
55735
55736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55737   unsigned int jresult ;
55738   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55739   bool result;
55740
55741   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55742   {
55743     try {
55744       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);
55745     } catch (std::out_of_range& e) {
55746       {
55747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (std::exception& e) {
55750       {
55751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55752       };
55753     } catch (Dali::DaliException e) {
55754       {
55755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55756       };
55757     } catch (...) {
55758       {
55759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55760       };
55761     }
55762   }
55763
55764   jresult = result;
55765   return jresult;
55766 }
55767
55768
55769 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55770   unsigned long jresult ;
55771   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55772   std::size_t result;
55773
55774   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55775   {
55776     try {
55777       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);
55778     } catch (std::out_of_range& e) {
55779       {
55780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55781       };
55782     } catch (std::exception& e) {
55783       {
55784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55785       };
55786     } catch (Dali::DaliException e) {
55787       {
55788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55789       };
55790     } catch (...) {
55791       {
55792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55793       };
55794     }
55795   }
55796
55797   jresult = (unsigned long)result;
55798   return jresult;
55799 }
55800
55801
55802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55803   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55804   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55805
55806   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55807   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55808   {
55809     try {
55810       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55811     } catch (std::out_of_range& e) {
55812       {
55813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55814       };
55815     } catch (std::exception& e) {
55816       {
55817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55818       };
55819     } catch (Dali::DaliException e) {
55820       {
55821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55822       };
55823     } catch (...) {
55824       {
55825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55826       };
55827     }
55828   }
55829
55830 }
55831
55832
55833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55834   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55835   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55836
55837   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55838   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55839   {
55840     try {
55841       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55842     } catch (std::out_of_range& e) {
55843       {
55844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55845       };
55846     } catch (std::exception& e) {
55847       {
55848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55849       };
55850     } catch (Dali::DaliException e) {
55851       {
55852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55853       };
55854     } catch (...) {
55855       {
55856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55857       };
55858     }
55859   }
55860
55861 }
55862
55863
55864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55865   unsigned int jresult ;
55866   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55867   Dali::Actor arg2 ;
55868   Dali::WheelEvent *arg3 = 0 ;
55869   Dali::Actor *argp2 ;
55870   bool result;
55871
55872   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55873   argp2 = (Dali::Actor *)jarg2;
55874   if (!argp2) {
55875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55876     return 0;
55877   }
55878   arg2 = *argp2;
55879   arg3 = (Dali::WheelEvent *)jarg3;
55880   if (!arg3) {
55881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55882     return 0;
55883   }
55884   {
55885     try {
55886       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55887     } catch (std::out_of_range& e) {
55888       {
55889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55890       };
55891     } catch (std::exception& e) {
55892       {
55893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55894       };
55895     } catch (Dali::DaliException e) {
55896       {
55897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55898       };
55899     } catch (...) {
55900       {
55901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55902       };
55903     }
55904   }
55905
55906   jresult = result;
55907   return jresult;
55908 }
55909
55910
55911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55912   void * jresult ;
55913   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55914
55915   {
55916     try {
55917       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55918     } catch (std::out_of_range& e) {
55919       {
55920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55921       };
55922     } catch (std::exception& e) {
55923       {
55924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55925       };
55926     } catch (Dali::DaliException e) {
55927       {
55928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55929       };
55930     } catch (...) {
55931       {
55932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55933       };
55934     }
55935   }
55936
55937   jresult = (void *)result;
55938   return jresult;
55939 }
55940
55941
55942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55943   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55944
55945   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55946   {
55947     try {
55948       delete arg1;
55949     } catch (std::out_of_range& e) {
55950       {
55951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55952       };
55953     } catch (std::exception& e) {
55954       {
55955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55956       };
55957     } catch (Dali::DaliException e) {
55958       {
55959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55960       };
55961     } catch (...) {
55962       {
55963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55964       };
55965     }
55966   }
55967
55968 }
55969
55970
55971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55972   unsigned int jresult ;
55973   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55974   bool result;
55975
55976   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55977   {
55978     try {
55979       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55980     } catch (std::out_of_range& e) {
55981       {
55982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55983       };
55984     } catch (std::exception& e) {
55985       {
55986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55987       };
55988     } catch (Dali::DaliException e) {
55989       {
55990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55991       };
55992     } catch (...) {
55993       {
55994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55995       };
55996     }
55997   }
55998
55999   jresult = result;
56000   return jresult;
56001 }
56002
56003
56004 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56005   unsigned long jresult ;
56006   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56007   std::size_t result;
56008
56009   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56010   {
56011     try {
56012       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56013     } catch (std::out_of_range& e) {
56014       {
56015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56016       };
56017     } catch (std::exception& e) {
56018       {
56019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56020       };
56021     } catch (Dali::DaliException e) {
56022       {
56023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56024       };
56025     } catch (...) {
56026       {
56027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56028       };
56029     }
56030   }
56031
56032   jresult = (unsigned long)result;
56033   return jresult;
56034 }
56035
56036
56037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56038   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56039   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56040
56041   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56042   arg2 = (void (*)(Dali::Actor))jarg2;
56043   {
56044     try {
56045       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56046     } catch (std::out_of_range& e) {
56047       {
56048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56049       };
56050     } catch (std::exception& e) {
56051       {
56052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56053       };
56054     } catch (Dali::DaliException e) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56057       };
56058     } catch (...) {
56059       {
56060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56061       };
56062     }
56063   }
56064
56065 }
56066
56067
56068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56069   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56070   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56071
56072   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56073   arg2 = (void (*)(Dali::Actor))jarg2;
56074   {
56075     try {
56076       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56077     } catch (std::out_of_range& e) {
56078       {
56079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56080       };
56081     } catch (std::exception& e) {
56082       {
56083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56084       };
56085     } catch (Dali::DaliException e) {
56086       {
56087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56088       };
56089     } catch (...) {
56090       {
56091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56092       };
56093     }
56094   }
56095
56096 }
56097
56098
56099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56100   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56101   Dali::Actor arg2 ;
56102   Dali::Actor *argp2 ;
56103
56104   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56105   argp2 = (Dali::Actor *)jarg2;
56106   if (!argp2) {
56107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56108     return ;
56109   }
56110   arg2 = *argp2;
56111   {
56112     try {
56113       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56114     } catch (std::out_of_range& e) {
56115       {
56116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56117       };
56118     } catch (std::exception& e) {
56119       {
56120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56121       };
56122     } catch (Dali::DaliException e) {
56123       {
56124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56125       };
56126     } catch (...) {
56127       {
56128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56129       };
56130     }
56131   }
56132
56133 }
56134
56135
56136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56137   void * jresult ;
56138   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56139
56140   {
56141     try {
56142       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56143     } catch (std::out_of_range& e) {
56144       {
56145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56146       };
56147     } catch (std::exception& e) {
56148       {
56149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56150       };
56151     } catch (Dali::DaliException e) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56154       };
56155     } catch (...) {
56156       {
56157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56158       };
56159     }
56160   }
56161
56162   jresult = (void *)result;
56163   return jresult;
56164 }
56165
56166
56167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56168   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56169
56170   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56171   {
56172     try {
56173       delete arg1;
56174     } catch (std::out_of_range& e) {
56175       {
56176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56177       };
56178     } catch (std::exception& e) {
56179       {
56180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56181       };
56182     } catch (Dali::DaliException e) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56185       };
56186     } catch (...) {
56187       {
56188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56189       };
56190     }
56191   }
56192
56193 }
56194
56195
56196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56197   unsigned int jresult ;
56198   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56199   bool result;
56200
56201   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56202   {
56203     try {
56204       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56205     } catch (std::out_of_range& e) {
56206       {
56207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (std::exception& e) {
56210       {
56211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (Dali::DaliException e) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56216       };
56217     } catch (...) {
56218       {
56219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56220       };
56221     }
56222   }
56223
56224   jresult = result;
56225   return jresult;
56226 }
56227
56228
56229 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56230   unsigned long jresult ;
56231   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56232   std::size_t result;
56233
56234   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56235   {
56236     try {
56237       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (Dali::DaliException e) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56249       };
56250     } catch (...) {
56251       {
56252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56253       };
56254     }
56255   }
56256
56257   jresult = (unsigned long)result;
56258   return jresult;
56259 }
56260
56261
56262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56263   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56264   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56265
56266   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56267   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56268   {
56269     try {
56270       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56271     } catch (std::out_of_range& e) {
56272       {
56273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56274       };
56275     } catch (std::exception& e) {
56276       {
56277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56278       };
56279     } catch (Dali::DaliException e) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56282       };
56283     } catch (...) {
56284       {
56285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56286       };
56287     }
56288   }
56289
56290 }
56291
56292
56293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56294   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56295   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56296
56297   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56298   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56299   {
56300     try {
56301       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56302     } catch (std::out_of_range& e) {
56303       {
56304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56305       };
56306     } catch (std::exception& e) {
56307       {
56308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56309       };
56310     } catch (Dali::DaliException e) {
56311       {
56312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56313       };
56314     } catch (...) {
56315       {
56316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56317       };
56318     }
56319   }
56320
56321 }
56322
56323
56324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56325   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56326   Dali::KeyEvent *arg2 = 0 ;
56327
56328   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56329   arg2 = (Dali::KeyEvent *)jarg2;
56330   if (!arg2) {
56331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56332     return ;
56333   }
56334   {
56335     try {
56336       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56337     } catch (std::out_of_range& e) {
56338       {
56339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56340       };
56341     } catch (std::exception& e) {
56342       {
56343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56344       };
56345     } catch (Dali::DaliException e) {
56346       {
56347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56348       };
56349     } catch (...) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56352       };
56353     }
56354   }
56355
56356 }
56357
56358
56359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56360   void * jresult ;
56361   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56362
56363   {
56364     try {
56365       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56366     } catch (std::out_of_range& e) {
56367       {
56368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56369       };
56370     } catch (std::exception& e) {
56371       {
56372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56373       };
56374     } catch (Dali::DaliException e) {
56375       {
56376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56377       };
56378     } catch (...) {
56379       {
56380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56381       };
56382     }
56383   }
56384
56385   jresult = (void *)result;
56386   return jresult;
56387 }
56388
56389
56390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56391   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56392
56393   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56394   {
56395     try {
56396       delete arg1;
56397     } catch (std::out_of_range& e) {
56398       {
56399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56400       };
56401     } catch (std::exception& e) {
56402       {
56403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56404       };
56405     } catch (Dali::DaliException e) {
56406       {
56407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56408       };
56409     } catch (...) {
56410       {
56411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56412       };
56413     }
56414   }
56415
56416 }
56417
56418
56419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56420   unsigned int jresult ;
56421   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56422   bool result;
56423
56424   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56425   {
56426     try {
56427       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56428     } catch (std::out_of_range& e) {
56429       {
56430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (std::exception& e) {
56433       {
56434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56435       };
56436     } catch (Dali::DaliException e) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56439       };
56440     } catch (...) {
56441       {
56442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56443       };
56444     }
56445   }
56446
56447   jresult = result;
56448   return jresult;
56449 }
56450
56451
56452 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56453   unsigned long jresult ;
56454   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56455   std::size_t result;
56456
56457   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56458   {
56459     try {
56460       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56461     } catch (std::out_of_range& e) {
56462       {
56463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (std::exception& e) {
56466       {
56467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56468       };
56469     } catch (Dali::DaliException e) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56472       };
56473     } catch (...) {
56474       {
56475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56476       };
56477     }
56478   }
56479
56480   jresult = (unsigned long)result;
56481   return jresult;
56482 }
56483
56484
56485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56486   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56487   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56488
56489   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56490   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56491   {
56492     try {
56493       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56494     } catch (std::out_of_range& e) {
56495       {
56496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56497       };
56498     } catch (std::exception& e) {
56499       {
56500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56501       };
56502     } catch (Dali::DaliException e) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56505       };
56506     } catch (...) {
56507       {
56508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56509       };
56510     }
56511   }
56512
56513 }
56514
56515
56516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56517   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56518   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56519
56520   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56521   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56522   {
56523     try {
56524       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56525     } catch (std::out_of_range& e) {
56526       {
56527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56528       };
56529     } catch (std::exception& e) {
56530       {
56531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56532       };
56533     } catch (Dali::DaliException e) {
56534       {
56535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56536       };
56537     } catch (...) {
56538       {
56539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56540       };
56541     }
56542   }
56543
56544 }
56545
56546
56547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56548   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56549   Dali::TouchData *arg2 = 0 ;
56550
56551   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56552   arg2 = (Dali::TouchData *)jarg2;
56553   if (!arg2) {
56554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56555     return ;
56556   }
56557   {
56558     try {
56559       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56560     } catch (std::out_of_range& e) {
56561       {
56562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56563       };
56564     } catch (std::exception& e) {
56565       {
56566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56567       };
56568     } catch (Dali::DaliException e) {
56569       {
56570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56571       };
56572     } catch (...) {
56573       {
56574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56575       };
56576     }
56577   }
56578
56579 }
56580
56581
56582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56583   void * jresult ;
56584   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56585
56586   {
56587     try {
56588       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56589     } catch (std::out_of_range& e) {
56590       {
56591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (std::exception& e) {
56594       {
56595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56596       };
56597     } catch (Dali::DaliException e) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56600       };
56601     } catch (...) {
56602       {
56603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56604       };
56605     }
56606   }
56607
56608   jresult = (void *)result;
56609   return jresult;
56610 }
56611
56612
56613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56614   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56615
56616   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56617   {
56618     try {
56619       delete arg1;
56620     } catch (std::out_of_range& e) {
56621       {
56622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56623       };
56624     } catch (std::exception& e) {
56625       {
56626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56627       };
56628     } catch (Dali::DaliException e) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56631       };
56632     } catch (...) {
56633       {
56634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56635       };
56636     }
56637   }
56638
56639 }
56640
56641
56642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56643   unsigned int jresult ;
56644   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56645   bool result;
56646
56647   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56648   {
56649     try {
56650       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56651     } catch (std::out_of_range& e) {
56652       {
56653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (std::exception& e) {
56656       {
56657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56658       };
56659     } catch (Dali::DaliException e) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56662       };
56663     } catch (...) {
56664       {
56665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56666       };
56667     }
56668   }
56669
56670   jresult = result;
56671   return jresult;
56672 }
56673
56674
56675 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56676   unsigned long jresult ;
56677   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56678   std::size_t result;
56679
56680   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56681   {
56682     try {
56683       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56684     } catch (std::out_of_range& e) {
56685       {
56686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56687       };
56688     } catch (std::exception& e) {
56689       {
56690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56691       };
56692     } catch (Dali::DaliException e) {
56693       {
56694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56695       };
56696     } catch (...) {
56697       {
56698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56699       };
56700     }
56701   }
56702
56703   jresult = (unsigned long)result;
56704   return jresult;
56705 }
56706
56707
56708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56709   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56710   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56711
56712   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56713   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56714   {
56715     try {
56716       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56717     } catch (std::out_of_range& e) {
56718       {
56719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56720       };
56721     } catch (std::exception& e) {
56722       {
56723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56724       };
56725     } catch (Dali::DaliException e) {
56726       {
56727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56728       };
56729     } catch (...) {
56730       {
56731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56732       };
56733     }
56734   }
56735
56736 }
56737
56738
56739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56740   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56741   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56742
56743   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56744   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56745   {
56746     try {
56747       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56748     } catch (std::out_of_range& e) {
56749       {
56750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56751       };
56752     } catch (std::exception& e) {
56753       {
56754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56755       };
56756     } catch (Dali::DaliException e) {
56757       {
56758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56759       };
56760     } catch (...) {
56761       {
56762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56763       };
56764     }
56765   }
56766
56767 }
56768
56769
56770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56771   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56772   Dali::WheelEvent *arg2 = 0 ;
56773
56774   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56775   arg2 = (Dali::WheelEvent *)jarg2;
56776   if (!arg2) {
56777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56778     return ;
56779   }
56780   {
56781     try {
56782       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56783     } catch (std::out_of_range& e) {
56784       {
56785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56786       };
56787     } catch (std::exception& e) {
56788       {
56789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56790       };
56791     } catch (Dali::DaliException e) {
56792       {
56793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56794       };
56795     } catch (...) {
56796       {
56797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56798       };
56799     }
56800   }
56801
56802 }
56803
56804
56805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56806   void * jresult ;
56807   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56808
56809   {
56810     try {
56811       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56812     } catch (std::out_of_range& e) {
56813       {
56814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56815       };
56816     } catch (std::exception& e) {
56817       {
56818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56819       };
56820     } catch (Dali::DaliException e) {
56821       {
56822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56823       };
56824     } catch (...) {
56825       {
56826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56827       };
56828     }
56829   }
56830
56831   jresult = (void *)result;
56832   return jresult;
56833 }
56834
56835
56836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56837   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56838
56839   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56840   {
56841     try {
56842       delete arg1;
56843     } catch (std::out_of_range& e) {
56844       {
56845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56846       };
56847     } catch (std::exception& e) {
56848       {
56849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56850       };
56851     } catch (Dali::DaliException e) {
56852       {
56853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56854       };
56855     } catch (...) {
56856       {
56857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56858       };
56859     }
56860   }
56861
56862 }
56863
56864
56865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56866   void * jresult ;
56867   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56868
56869   {
56870     try {
56871       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56872     } catch (std::out_of_range& e) {
56873       {
56874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56875       };
56876     } catch (std::exception& e) {
56877       {
56878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56879       };
56880     } catch (Dali::DaliException e) {
56881       {
56882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56883       };
56884     } catch (...) {
56885       {
56886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56887       };
56888     }
56889   }
56890
56891   jresult = (void *)result;
56892   return jresult;
56893 }
56894
56895
56896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56897   void * jresult ;
56898   Dali::Radian arg1 ;
56899   Dali::Radian arg2 ;
56900   Dali::Radian *argp1 ;
56901   Dali::Radian *argp2 ;
56902   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56903
56904   argp1 = (Dali::Radian *)jarg1;
56905   if (!argp1) {
56906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56907     return 0;
56908   }
56909   arg1 = *argp1;
56910   argp2 = (Dali::Radian *)jarg2;
56911   if (!argp2) {
56912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56913     return 0;
56914   }
56915   arg2 = *argp2;
56916   {
56917     try {
56918       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56919     } catch (std::out_of_range& e) {
56920       {
56921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56922       };
56923     } catch (std::exception& e) {
56924       {
56925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56926       };
56927     } catch (Dali::DaliException e) {
56928       {
56929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56930       };
56931     } catch (...) {
56932       {
56933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56934       };
56935     }
56936   }
56937
56938   jresult = (void *)result;
56939   return jresult;
56940 }
56941
56942
56943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56944   void * jresult ;
56945   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56946   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56947
56948   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56949   if (!arg1) {
56950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56951     return 0;
56952   }
56953   {
56954     try {
56955       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56956     } catch (std::out_of_range& e) {
56957       {
56958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56959       };
56960     } catch (std::exception& e) {
56961       {
56962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56963       };
56964     } catch (Dali::DaliException e) {
56965       {
56966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56967       };
56968     } catch (...) {
56969       {
56970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56971       };
56972     }
56973   }
56974
56975   jresult = (void *)result;
56976   return jresult;
56977 }
56978
56979
56980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56981   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56982   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56983
56984   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56985   arg2 = (Dali::Radian *)jarg2;
56986   if (arg1) (arg1)->first = *arg2;
56987 }
56988
56989
56990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56991   void * jresult ;
56992   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56993   Dali::Radian *result = 0 ;
56994
56995   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56996   result = (Dali::Radian *)& ((arg1)->first);
56997   jresult = (void *)result;
56998   return jresult;
56999 }
57000
57001
57002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57003   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57004   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57005
57006   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57007   arg2 = (Dali::Radian *)jarg2;
57008   if (arg1) (arg1)->second = *arg2;
57009 }
57010
57011
57012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57013   void * jresult ;
57014   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57015   Dali::Radian *result = 0 ;
57016
57017   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57018   result = (Dali::Radian *)& ((arg1)->second);
57019   jresult = (void *)result;
57020   return jresult;
57021 }
57022
57023
57024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57025   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57026
57027   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57028   {
57029     try {
57030       delete arg1;
57031     } catch (std::out_of_range& e) {
57032       {
57033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57034       };
57035     } catch (std::exception& e) {
57036       {
57037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57038       };
57039     } catch (Dali::DaliException e) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57042       };
57043     } catch (...) {
57044       {
57045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57046       };
57047     }
57048   }
57049
57050 }
57051
57052
57053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57054   unsigned int jresult ;
57055   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57056   bool result;
57057
57058   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57059   {
57060     try {
57061       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);
57062     } catch (std::out_of_range& e) {
57063       {
57064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57065       };
57066     } catch (std::exception& e) {
57067       {
57068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57069       };
57070     } catch (Dali::DaliException e) {
57071       {
57072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57073       };
57074     } catch (...) {
57075       {
57076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57077       };
57078     }
57079   }
57080
57081   jresult = result;
57082   return jresult;
57083 }
57084
57085
57086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57087   unsigned long jresult ;
57088   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57089   std::size_t result;
57090
57091   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57092   {
57093     try {
57094       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);
57095     } catch (std::out_of_range& e) {
57096       {
57097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57098       };
57099     } catch (std::exception& e) {
57100       {
57101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57102       };
57103     } catch (Dali::DaliException e) {
57104       {
57105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57106       };
57107     } catch (...) {
57108       {
57109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57110       };
57111     }
57112   }
57113
57114   jresult = (unsigned long)result;
57115   return jresult;
57116 }
57117
57118
57119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57120   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57121   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57122
57123   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57124   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57125   {
57126     try {
57127       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57128     } catch (std::out_of_range& e) {
57129       {
57130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57131       };
57132     } catch (std::exception& e) {
57133       {
57134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57135       };
57136     } catch (Dali::DaliException e) {
57137       {
57138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57139       };
57140     } catch (...) {
57141       {
57142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57143       };
57144     }
57145   }
57146
57147 }
57148
57149
57150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57151   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57152   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57153
57154   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57155   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57156   {
57157     try {
57158       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57159     } catch (std::out_of_range& e) {
57160       {
57161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57162       };
57163     } catch (std::exception& e) {
57164       {
57165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57166       };
57167     } catch (Dali::DaliException e) {
57168       {
57169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57170       };
57171     } catch (...) {
57172       {
57173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57174       };
57175     }
57176   }
57177
57178 }
57179
57180
57181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57182   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57183   Dali::Actor arg2 ;
57184   Dali::PanGesture *arg3 = 0 ;
57185   Dali::Actor *argp2 ;
57186
57187   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57188   argp2 = (Dali::Actor *)jarg2;
57189   if (!argp2) {
57190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57191     return ;
57192   }
57193   arg2 = *argp2;
57194   arg3 = (Dali::PanGesture *)jarg3;
57195   if (!arg3) {
57196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57197     return ;
57198   }
57199   {
57200     try {
57201       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57202     } catch (std::out_of_range& e) {
57203       {
57204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57205       };
57206     } catch (std::exception& e) {
57207       {
57208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57209       };
57210     } catch (Dali::DaliException e) {
57211       {
57212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57213       };
57214     } catch (...) {
57215       {
57216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57217       };
57218     }
57219   }
57220
57221 }
57222
57223
57224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57225   void * jresult ;
57226   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57227
57228   {
57229     try {
57230       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57231     } catch (std::out_of_range& e) {
57232       {
57233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57234       };
57235     } catch (std::exception& e) {
57236       {
57237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57238       };
57239     } catch (Dali::DaliException e) {
57240       {
57241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57242       };
57243     } catch (...) {
57244       {
57245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57246       };
57247     }
57248   }
57249
57250   jresult = (void *)result;
57251   return jresult;
57252 }
57253
57254
57255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57256   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57257
57258   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57259   {
57260     try {
57261       delete arg1;
57262     } catch (std::out_of_range& e) {
57263       {
57264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57265       };
57266     } catch (std::exception& e) {
57267       {
57268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57269       };
57270     } catch (Dali::DaliException e) {
57271       {
57272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57273       };
57274     } catch (...) {
57275       {
57276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57277       };
57278     }
57279   }
57280
57281 }
57282
57283
57284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57285   unsigned int jresult ;
57286   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57287   bool result;
57288
57289   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57290   {
57291     try {
57292       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);
57293     } catch (std::out_of_range& e) {
57294       {
57295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57296       };
57297     } catch (std::exception& e) {
57298       {
57299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57300       };
57301     } catch (Dali::DaliException e) {
57302       {
57303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57304       };
57305     } catch (...) {
57306       {
57307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57308       };
57309     }
57310   }
57311
57312   jresult = result;
57313   return jresult;
57314 }
57315
57316
57317 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57318   unsigned long jresult ;
57319   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57320   std::size_t result;
57321
57322   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57323   {
57324     try {
57325       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);
57326     } catch (std::out_of_range& e) {
57327       {
57328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57329       };
57330     } catch (std::exception& e) {
57331       {
57332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57333       };
57334     } catch (Dali::DaliException e) {
57335       {
57336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57337       };
57338     } catch (...) {
57339       {
57340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57341       };
57342     }
57343   }
57344
57345   jresult = (unsigned long)result;
57346   return jresult;
57347 }
57348
57349
57350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57351   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57352   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57353
57354   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57355   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57356   {
57357     try {
57358       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57359     } catch (std::out_of_range& e) {
57360       {
57361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57362       };
57363     } catch (std::exception& e) {
57364       {
57365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57366       };
57367     } catch (Dali::DaliException e) {
57368       {
57369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57370       };
57371     } catch (...) {
57372       {
57373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57374       };
57375     }
57376   }
57377
57378 }
57379
57380
57381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57382   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57383   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57384
57385   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57386   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57387   {
57388     try {
57389       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57390     } catch (std::out_of_range& e) {
57391       {
57392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57393       };
57394     } catch (std::exception& e) {
57395       {
57396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57397       };
57398     } catch (Dali::DaliException e) {
57399       {
57400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57401       };
57402     } catch (...) {
57403       {
57404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57405       };
57406     }
57407   }
57408
57409 }
57410
57411
57412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57413   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57414   Dali::Actor arg2 ;
57415   Dali::PinchGesture *arg3 = 0 ;
57416   Dali::Actor *argp2 ;
57417
57418   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57419   argp2 = (Dali::Actor *)jarg2;
57420   if (!argp2) {
57421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57422     return ;
57423   }
57424   arg2 = *argp2;
57425   arg3 = (Dali::PinchGesture *)jarg3;
57426   if (!arg3) {
57427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57428     return ;
57429   }
57430   {
57431     try {
57432       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57433     } catch (std::out_of_range& e) {
57434       {
57435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57436       };
57437     } catch (std::exception& e) {
57438       {
57439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57440       };
57441     } catch (Dali::DaliException e) {
57442       {
57443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57444       };
57445     } catch (...) {
57446       {
57447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57448       };
57449     }
57450   }
57451
57452 }
57453
57454
57455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57456   void * jresult ;
57457   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57458
57459   {
57460     try {
57461       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57462     } catch (std::out_of_range& e) {
57463       {
57464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57465       };
57466     } catch (std::exception& e) {
57467       {
57468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57469       };
57470     } catch (Dali::DaliException e) {
57471       {
57472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57473       };
57474     } catch (...) {
57475       {
57476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57477       };
57478     }
57479   }
57480
57481   jresult = (void *)result;
57482   return jresult;
57483 }
57484
57485
57486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57487   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57488
57489   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57490   {
57491     try {
57492       delete arg1;
57493     } catch (std::out_of_range& e) {
57494       {
57495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57496       };
57497     } catch (std::exception& e) {
57498       {
57499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57500       };
57501     } catch (Dali::DaliException e) {
57502       {
57503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57504       };
57505     } catch (...) {
57506       {
57507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57508       };
57509     }
57510   }
57511
57512 }
57513
57514
57515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57516   unsigned int jresult ;
57517   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57518   bool result;
57519
57520   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57521   {
57522     try {
57523       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);
57524     } catch (std::out_of_range& e) {
57525       {
57526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (std::exception& e) {
57529       {
57530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57531       };
57532     } catch (Dali::DaliException e) {
57533       {
57534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57535       };
57536     } catch (...) {
57537       {
57538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57539       };
57540     }
57541   }
57542
57543   jresult = result;
57544   return jresult;
57545 }
57546
57547
57548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57549   unsigned long jresult ;
57550   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57551   std::size_t result;
57552
57553   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57554   {
57555     try {
57556       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);
57557     } catch (std::out_of_range& e) {
57558       {
57559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57560       };
57561     } catch (std::exception& e) {
57562       {
57563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57564       };
57565     } catch (Dali::DaliException e) {
57566       {
57567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57568       };
57569     } catch (...) {
57570       {
57571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57572       };
57573     }
57574   }
57575
57576   jresult = (unsigned long)result;
57577   return jresult;
57578 }
57579
57580
57581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57582   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57583   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57584
57585   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57586   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57587   {
57588     try {
57589       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57590     } catch (std::out_of_range& e) {
57591       {
57592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57593       };
57594     } catch (std::exception& e) {
57595       {
57596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57597       };
57598     } catch (Dali::DaliException e) {
57599       {
57600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57601       };
57602     } catch (...) {
57603       {
57604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57605       };
57606     }
57607   }
57608
57609 }
57610
57611
57612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57613   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57614   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57615
57616   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57617   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57618   {
57619     try {
57620       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57621     } catch (std::out_of_range& e) {
57622       {
57623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57624       };
57625     } catch (std::exception& e) {
57626       {
57627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57628       };
57629     } catch (Dali::DaliException e) {
57630       {
57631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57632       };
57633     } catch (...) {
57634       {
57635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57636       };
57637     }
57638   }
57639
57640 }
57641
57642
57643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57644   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57645   Dali::Actor arg2 ;
57646   Dali::TapGesture *arg3 = 0 ;
57647   Dali::Actor *argp2 ;
57648
57649   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57650   argp2 = (Dali::Actor *)jarg2;
57651   if (!argp2) {
57652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57653     return ;
57654   }
57655   arg2 = *argp2;
57656   arg3 = (Dali::TapGesture *)jarg3;
57657   if (!arg3) {
57658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57659     return ;
57660   }
57661   {
57662     try {
57663       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57664     } catch (std::out_of_range& e) {
57665       {
57666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57667       };
57668     } catch (std::exception& e) {
57669       {
57670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57671       };
57672     } catch (Dali::DaliException e) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57675       };
57676     } catch (...) {
57677       {
57678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57679       };
57680     }
57681   }
57682
57683 }
57684
57685
57686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57687   void * jresult ;
57688   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57689
57690   {
57691     try {
57692       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57693     } catch (std::out_of_range& e) {
57694       {
57695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57696       };
57697     } catch (std::exception& e) {
57698       {
57699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57700       };
57701     } catch (Dali::DaliException e) {
57702       {
57703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57704       };
57705     } catch (...) {
57706       {
57707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57708       };
57709     }
57710   }
57711
57712   jresult = (void *)result;
57713   return jresult;
57714 }
57715
57716
57717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57718   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57719
57720   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57721   {
57722     try {
57723       delete arg1;
57724     } catch (std::out_of_range& e) {
57725       {
57726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57727       };
57728     } catch (std::exception& e) {
57729       {
57730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57731       };
57732     } catch (Dali::DaliException e) {
57733       {
57734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57735       };
57736     } catch (...) {
57737       {
57738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57739       };
57740     }
57741   }
57742
57743 }
57744
57745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57746   unsigned int jresult ;
57747   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57748   bool result;
57749
57750   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57751   {
57752     try {
57753       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57754     } catch (std::out_of_range& e) {
57755       {
57756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (std::exception& e) {
57759       {
57760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57761       };
57762     } catch (Dali::DaliException e) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57765       };
57766     } catch (...) {
57767       {
57768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57769       };
57770     }
57771   }
57772
57773   jresult = result;
57774   return jresult;
57775 }
57776
57777
57778 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57779   unsigned long jresult ;
57780   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57781   std::size_t result;
57782
57783   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57784   {
57785     try {
57786       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57787     } catch (std::out_of_range& e) {
57788       {
57789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57790       };
57791     } catch (std::exception& e) {
57792       {
57793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57794       };
57795     } catch (Dali::DaliException e) {
57796       {
57797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57798       };
57799     } catch (...) {
57800       {
57801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57802       };
57803     }
57804   }
57805
57806   jresult = (unsigned long)result;
57807   return jresult;
57808 }
57809
57810
57811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57812   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57813   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57814
57815   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57816   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57817   {
57818     try {
57819       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57820     } catch (std::out_of_range& e) {
57821       {
57822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57823       };
57824     } catch (std::exception& e) {
57825       {
57826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57827       };
57828     } catch (Dali::DaliException e) {
57829       {
57830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57831       };
57832     } catch (...) {
57833       {
57834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57835       };
57836     }
57837   }
57838
57839 }
57840
57841
57842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57843   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57844   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57845
57846   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57847   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57848   {
57849     try {
57850       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57851     } catch (std::out_of_range& e) {
57852       {
57853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57854       };
57855     } catch (std::exception& e) {
57856       {
57857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57858       };
57859     } catch (Dali::DaliException e) {
57860       {
57861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57862       };
57863     } catch (...) {
57864       {
57865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57866       };
57867     }
57868   }
57869
57870 }
57871
57872
57873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57874   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57875   Dali::ResourceImage arg2 ;
57876   Dali::ResourceImage *argp2 ;
57877
57878   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57879   argp2 = (Dali::ResourceImage *)jarg2;
57880   if (!argp2) {
57881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57882     return ;
57883   }
57884   arg2 = *argp2;
57885   {
57886     try {
57887       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57888     } catch (std::out_of_range& e) {
57889       {
57890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57891       };
57892     } catch (std::exception& e) {
57893       {
57894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57895       };
57896     } catch (Dali::DaliException e) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57899       };
57900     } catch (...) {
57901       {
57902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57903       };
57904     }
57905   }
57906
57907 }
57908
57909
57910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57911   void * jresult ;
57912   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57913
57914   {
57915     try {
57916       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57917     } catch (std::out_of_range& e) {
57918       {
57919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57920       };
57921     } catch (std::exception& e) {
57922       {
57923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57924       };
57925     } catch (Dali::DaliException e) {
57926       {
57927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57928       };
57929     } catch (...) {
57930       {
57931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57932       };
57933     }
57934   }
57935
57936   jresult = (void *)result;
57937   return jresult;
57938 }
57939
57940
57941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57942   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57943
57944   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57945   {
57946     try {
57947       delete arg1;
57948     } catch (std::out_of_range& e) {
57949       {
57950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57951       };
57952     } catch (std::exception& e) {
57953       {
57954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57955       };
57956     } catch (Dali::DaliException e) {
57957       {
57958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57959       };
57960     } catch (...) {
57961       {
57962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57963       };
57964     }
57965   }
57966
57967 }
57968
57969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57970   unsigned int jresult ;
57971   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57972   bool result = false;
57973
57974   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57975   {
57976     try {
57977       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);
57978     } catch (std::out_of_range& e) {
57979       {
57980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57981       };
57982     } catch (std::exception& e) {
57983       {
57984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57985       };
57986     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57987   }
57988   jresult = result;
57989   return jresult;
57990 }
57991
57992 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57993   unsigned long jresult ;
57994   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57995   std::size_t result = 0;
57996
57997   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57998   {
57999     try {
58000       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);
58001     } catch (std::out_of_range& e) {
58002       {
58003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58004       };
58005     } catch (std::exception& e) {
58006       {
58007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58008       };
58009     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58010   }
58011   jresult = (unsigned long)result;
58012   return jresult;
58013 }
58014
58015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58016   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58017   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58018
58019   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58020   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58021   {
58022     try {
58023       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58024     } catch (std::out_of_range& e) {
58025       {
58026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58027       };
58028     } catch (std::exception& e) {
58029       {
58030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58031       };
58032     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58033   }
58034 }
58035
58036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58037   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58038   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58039
58040   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58041   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58042   {
58043     try {
58044       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58045     } catch (std::out_of_range& e) {
58046       {
58047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58048       };
58049     } catch (std::exception& e) {
58050       {
58051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58052       };
58053     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58054   }
58055 }
58056
58057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58058   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58059   Dali::Actor arg2 ;
58060   //bool arg3 ;
58061   Dali::LayoutDirection::Type arg4 ;
58062   Dali::Actor *argp2 ;
58063
58064   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58065   argp2 = (Dali::Actor *)jarg2;
58066   if (!argp2) {
58067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58068     return ;
58069   }
58070   arg2 = *argp2;
58071   //arg3 = jarg3 ? true : false;
58072   arg4 = (Dali::LayoutDirection::Type)jarg4;
58073   {
58074     try {
58075       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58076     } catch (std::out_of_range& e) {
58077       {
58078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58079       };
58080     } catch (std::exception& e) {
58081       {
58082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58083       };
58084     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58085   }
58086 }
58087
58088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58089   void * jresult ;
58090   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58091
58092   {
58093     try {
58094       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58095     } catch (std::out_of_range& e) {
58096       {
58097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58098       };
58099     } catch (std::exception& e) {
58100       {
58101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58102       };
58103     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58104   }
58105   jresult = (void *)result;
58106   return jresult;
58107 }
58108
58109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58110   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58111
58112   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58113   {
58114     try {
58115       delete arg1;
58116     } catch (std::out_of_range& e) {
58117       {
58118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58119       };
58120     } catch (std::exception& e) {
58121       {
58122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58123       };
58124     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58125   }
58126 }
58127
58128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58129   unsigned int jresult ;
58130   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58131   bool result;
58132
58133   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58134   {
58135     try {
58136       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);
58137     } catch (std::out_of_range& e) {
58138       {
58139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58140       };
58141     } catch (std::exception& e) {
58142       {
58143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58144       };
58145     } catch (Dali::DaliException e) {
58146       {
58147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58148       };
58149     } catch (...) {
58150       {
58151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58152       };
58153     }
58154   }
58155
58156   jresult = result;
58157   return jresult;
58158 }
58159
58160
58161 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58162   unsigned long jresult ;
58163   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58164   std::size_t result;
58165
58166   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58167   {
58168     try {
58169       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);
58170     } catch (std::out_of_range& e) {
58171       {
58172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (std::exception& e) {
58175       {
58176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58177       };
58178     } catch (Dali::DaliException e) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58181       };
58182     } catch (...) {
58183       {
58184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58185       };
58186     }
58187   }
58188
58189   jresult = (unsigned long)result;
58190   return jresult;
58191 }
58192
58193
58194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58195   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58196   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58197
58198   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58199   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58200   {
58201     try {
58202       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58203     } catch (std::out_of_range& e) {
58204       {
58205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58206       };
58207     } catch (std::exception& e) {
58208       {
58209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58210       };
58211     } catch (Dali::DaliException e) {
58212       {
58213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58214       };
58215     } catch (...) {
58216       {
58217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58218       };
58219     }
58220   }
58221
58222 }
58223
58224
58225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58226   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58227   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58228
58229   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58230   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58231   {
58232     try {
58233       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58234     } catch (std::out_of_range& e) {
58235       {
58236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58237       };
58238     } catch (std::exception& e) {
58239       {
58240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58241       };
58242     } catch (Dali::DaliException e) {
58243       {
58244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58245       };
58246     } catch (...) {
58247       {
58248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58249       };
58250     }
58251   }
58252
58253 }
58254
58255
58256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58257   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58258   Dali::Actor arg2 ;
58259   bool arg3 ;
58260   Dali::DevelActor::VisibilityChange::Type arg4 ;
58261   Dali::Actor *argp2 ;
58262
58263   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58264   argp2 = (Dali::Actor *)jarg2;
58265   if (!argp2) {
58266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58267     return ;
58268   }
58269   arg2 = *argp2;
58270   arg3 = jarg3 ? true : false;
58271   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58272   {
58273     try {
58274       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58275     } catch (std::out_of_range& e) {
58276       {
58277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58278       };
58279     } catch (std::exception& e) {
58280       {
58281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58282       };
58283     } catch (Dali::DaliException e) {
58284       {
58285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58286       };
58287     } catch (...) {
58288       {
58289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58290       };
58291     }
58292   }
58293
58294 }
58295
58296
58297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58298   void * jresult ;
58299   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58300
58301   {
58302     try {
58303       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58304     } catch (std::out_of_range& e) {
58305       {
58306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (std::exception& e) {
58309       {
58310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58311       };
58312     } catch (Dali::DaliException e) {
58313       {
58314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58315       };
58316     } catch (...) {
58317       {
58318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58319       };
58320     }
58321   }
58322
58323   jresult = (void *)result;
58324   return jresult;
58325 }
58326
58327
58328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58329   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58330
58331   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58332   {
58333     try {
58334       delete arg1;
58335     } catch (std::out_of_range& e) {
58336       {
58337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58338       };
58339     } catch (std::exception& e) {
58340       {
58341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58342       };
58343     } catch (Dali::DaliException e) {
58344       {
58345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58346       };
58347     } catch (...) {
58348       {
58349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58350       };
58351     }
58352   }
58353
58354 }
58355
58356
58357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58358   void * jresult ;
58359   Dali::Timer *result = 0 ;
58360
58361   {
58362     try {
58363       result = (Dali::Timer *)new Dali::Timer();
58364     } catch (std::out_of_range& e) {
58365       {
58366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (std::exception& e) {
58369       {
58370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58371       };
58372     } catch (Dali::DaliException e) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58375       };
58376     } catch (...) {
58377       {
58378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58379       };
58380     }
58381   }
58382
58383   jresult = (void *)result;
58384   return jresult;
58385 }
58386
58387
58388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58389   void * jresult ;
58390   unsigned int arg1 ;
58391   Dali::Timer result;
58392
58393   arg1 = (unsigned int)jarg1;
58394   {
58395     try {
58396       result = Dali::Timer::New(arg1);
58397     } catch (std::out_of_range& e) {
58398       {
58399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58400       };
58401     } catch (std::exception& e) {
58402       {
58403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58404       };
58405     } catch (Dali::DaliException e) {
58406       {
58407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58408       };
58409     } catch (...) {
58410       {
58411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58412       };
58413     }
58414   }
58415
58416   jresult = new Dali::Timer((const Dali::Timer &)result);
58417   return jresult;
58418 }
58419
58420
58421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58422   void * jresult ;
58423   Dali::Timer *arg1 = 0 ;
58424   Dali::Timer *result = 0 ;
58425
58426   arg1 = (Dali::Timer *)jarg1;
58427   if (!arg1) {
58428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58429     return 0;
58430   }
58431   {
58432     try {
58433       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58434     } catch (std::out_of_range& e) {
58435       {
58436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (std::exception& e) {
58439       {
58440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58441       };
58442     } catch (Dali::DaliException e) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58445       };
58446     } catch (...) {
58447       {
58448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58449       };
58450     }
58451   }
58452
58453   jresult = (void *)result;
58454   return jresult;
58455 }
58456
58457
58458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58459   void * jresult ;
58460   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58461   Dali::Timer *arg2 = 0 ;
58462   Dali::Timer *result = 0 ;
58463
58464   arg1 = (Dali::Timer *)jarg1;
58465   arg2 = (Dali::Timer *)jarg2;
58466   if (!arg2) {
58467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58468     return 0;
58469   }
58470   {
58471     try {
58472       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58473     } catch (std::out_of_range& e) {
58474       {
58475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58476       };
58477     } catch (std::exception& e) {
58478       {
58479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58480       };
58481     } catch (Dali::DaliException e) {
58482       {
58483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58484       };
58485     } catch (...) {
58486       {
58487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58488       };
58489     }
58490   }
58491
58492   jresult = (void *)result;
58493   return jresult;
58494 }
58495
58496
58497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58498   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58499
58500   arg1 = (Dali::Timer *)jarg1;
58501   {
58502     try {
58503       delete arg1;
58504     } catch (std::out_of_range& e) {
58505       {
58506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58507       };
58508     } catch (std::exception& e) {
58509       {
58510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58511       };
58512     } catch (Dali::DaliException e) {
58513       {
58514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58515       };
58516     } catch (...) {
58517       {
58518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58519       };
58520     }
58521   }
58522
58523 }
58524
58525
58526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58527   void * jresult ;
58528   Dali::BaseHandle arg1 ;
58529   Dali::BaseHandle *argp1 ;
58530   Dali::Timer result;
58531
58532   argp1 = (Dali::BaseHandle *)jarg1;
58533   if (!argp1) {
58534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58535     return 0;
58536   }
58537   arg1 = *argp1;
58538   {
58539     try {
58540       result = Dali::Timer::DownCast(arg1);
58541     } catch (std::out_of_range& e) {
58542       {
58543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58544       };
58545     } catch (std::exception& e) {
58546       {
58547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58548       };
58549     } catch (Dali::DaliException e) {
58550       {
58551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58552       };
58553     } catch (...) {
58554       {
58555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58556       };
58557     }
58558   }
58559
58560   jresult = new Dali::Timer((const Dali::Timer &)result);
58561   return jresult;
58562 }
58563
58564
58565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58566   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58567
58568   arg1 = (Dali::Timer *)jarg1;
58569   {
58570     try {
58571       (arg1)->Start();
58572     } catch (std::out_of_range& e) {
58573       {
58574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58575       };
58576     } catch (std::exception& e) {
58577       {
58578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58579       };
58580     } catch (Dali::DaliException e) {
58581       {
58582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58583       };
58584     } catch (...) {
58585       {
58586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58587       };
58588     }
58589   }
58590
58591 }
58592
58593
58594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58595   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58596
58597   arg1 = (Dali::Timer *)jarg1;
58598   {
58599     try {
58600       (arg1)->Stop();
58601     } catch (std::out_of_range& e) {
58602       {
58603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58604       };
58605     } catch (std::exception& e) {
58606       {
58607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58608       };
58609     } catch (Dali::DaliException e) {
58610       {
58611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58612       };
58613     } catch (...) {
58614       {
58615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58616       };
58617     }
58618   }
58619
58620 }
58621
58622
58623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58624   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58625   unsigned int arg2 ;
58626
58627   arg1 = (Dali::Timer *)jarg1;
58628   arg2 = (unsigned int)jarg2;
58629   {
58630     try {
58631       (arg1)->SetInterval(arg2);
58632     } catch (std::out_of_range& e) {
58633       {
58634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58635       };
58636     } catch (std::exception& e) {
58637       {
58638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58639       };
58640     } catch (Dali::DaliException e) {
58641       {
58642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58643       };
58644     } catch (...) {
58645       {
58646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58647       };
58648     }
58649   }
58650
58651 }
58652
58653
58654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58655   unsigned int jresult ;
58656   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58657   unsigned int result;
58658
58659   arg1 = (Dali::Timer *)jarg1;
58660   {
58661     try {
58662       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58663     } catch (std::out_of_range& e) {
58664       {
58665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (std::exception& e) {
58668       {
58669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58670       };
58671     } catch (Dali::DaliException e) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58674       };
58675     } catch (...) {
58676       {
58677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58678       };
58679     }
58680   }
58681
58682   jresult = result;
58683   return jresult;
58684 }
58685
58686
58687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58688   unsigned int jresult ;
58689   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58690   bool result;
58691
58692   arg1 = (Dali::Timer *)jarg1;
58693   {
58694     try {
58695       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58696     } catch (std::out_of_range& e) {
58697       {
58698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (std::exception& e) {
58701       {
58702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58703       };
58704     } catch (Dali::DaliException e) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58707       };
58708     } catch (...) {
58709       {
58710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58711       };
58712     }
58713   }
58714
58715   jresult = result;
58716   return jresult;
58717 }
58718
58719
58720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58721   void * jresult ;
58722   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58723   Dali::Timer::TimerSignalType *result = 0 ;
58724
58725   arg1 = (Dali::Timer *)jarg1;
58726   {
58727     try {
58728       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58729     } catch (std::out_of_range& e) {
58730       {
58731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58732       };
58733     } catch (std::exception& e) {
58734       {
58735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58736       };
58737     } catch (Dali::DaliException e) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58740       };
58741     } catch (...) {
58742       {
58743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58744       };
58745     }
58746   }
58747
58748   jresult = (void *)result;
58749   return jresult;
58750 }
58751
58752
58753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58754   void * jresult ;
58755   Dali::DragAndDropDetector *result = 0 ;
58756
58757   {
58758     try {
58759       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58760     } catch (std::out_of_range& e) {
58761       {
58762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58763       };
58764     } catch (std::exception& e) {
58765       {
58766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58767       };
58768     } catch (Dali::DaliException e) {
58769       {
58770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58771       };
58772     } catch (...) {
58773       {
58774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58775       };
58776     }
58777   }
58778
58779   jresult = (void *)result;
58780   return jresult;
58781 }
58782
58783
58784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58785   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58786
58787   arg1 = (Dali::DragAndDropDetector *)jarg1;
58788   {
58789     try {
58790       delete arg1;
58791     } catch (std::out_of_range& e) {
58792       {
58793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58794       };
58795     } catch (std::exception& e) {
58796       {
58797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58798       };
58799     } catch (Dali::DaliException e) {
58800       {
58801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58802       };
58803     } catch (...) {
58804       {
58805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58806       };
58807     }
58808   }
58809
58810 }
58811
58812
58813 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58814   char * jresult ;
58815   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58816   std::string *result = 0 ;
58817
58818   arg1 = (Dali::DragAndDropDetector *)jarg1;
58819   {
58820     try {
58821       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58822     } catch (std::out_of_range& e) {
58823       {
58824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (std::exception& e) {
58827       {
58828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58829       };
58830     } catch (Dali::DaliException e) {
58831       {
58832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58833       };
58834     } catch (...) {
58835       {
58836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58837       };
58838     }
58839   }
58840
58841   jresult = SWIG_csharp_string_callback(result->c_str());
58842   return jresult;
58843 }
58844
58845
58846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58847   void * jresult ;
58848   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58849   Dali::Vector2 result;
58850
58851   arg1 = (Dali::DragAndDropDetector *)jarg1;
58852   {
58853     try {
58854       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58855     } catch (std::out_of_range& e) {
58856       {
58857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (std::exception& e) {
58860       {
58861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58862       };
58863     } catch (Dali::DaliException e) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58866       };
58867     } catch (...) {
58868       {
58869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58870       };
58871     }
58872   }
58873
58874   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58875   return jresult;
58876 }
58877
58878
58879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58880   void * jresult ;
58881   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58882   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58883
58884   arg1 = (Dali::DragAndDropDetector *)jarg1;
58885   {
58886     try {
58887       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58888     } catch (std::out_of_range& e) {
58889       {
58890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (std::exception& e) {
58893       {
58894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58895       };
58896     } catch (Dali::DaliException e) {
58897       {
58898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58899       };
58900     } catch (...) {
58901       {
58902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58903       };
58904     }
58905   }
58906
58907   jresult = (void *)result;
58908   return jresult;
58909 }
58910
58911
58912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58913   void * jresult ;
58914   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58915   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58916
58917   arg1 = (Dali::DragAndDropDetector *)jarg1;
58918   {
58919     try {
58920       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58921     } catch (std::out_of_range& e) {
58922       {
58923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (std::exception& e) {
58926       {
58927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58928       };
58929     } catch (Dali::DaliException e) {
58930       {
58931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58932       };
58933     } catch (...) {
58934       {
58935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58936       };
58937     }
58938   }
58939
58940   jresult = (void *)result;
58941   return jresult;
58942 }
58943
58944
58945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58946   void * jresult ;
58947   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58948   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58949
58950   arg1 = (Dali::DragAndDropDetector *)jarg1;
58951   {
58952     try {
58953       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58954     } catch (std::out_of_range& e) {
58955       {
58956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58957       };
58958     } catch (std::exception& e) {
58959       {
58960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58961       };
58962     } catch (Dali::DaliException e) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58965       };
58966     } catch (...) {
58967       {
58968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58969       };
58970     }
58971   }
58972
58973   jresult = (void *)result;
58974   return jresult;
58975 }
58976
58977
58978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58979   void * jresult ;
58980   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58981   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58982
58983   arg1 = (Dali::DragAndDropDetector *)jarg1;
58984   {
58985     try {
58986       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58987     } catch (std::out_of_range& e) {
58988       {
58989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58990       };
58991     } catch (std::exception& e) {
58992       {
58993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58994       };
58995     } catch (Dali::DaliException e) {
58996       {
58997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58998       };
58999     } catch (...) {
59000       {
59001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59002       };
59003     }
59004   }
59005
59006   jresult = (void *)result;
59007   return jresult;
59008 }
59009
59010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59011   unsigned int jresult ;
59012   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59013   bool result;
59014
59015   arg1 = (Dali::Signal< bool () > *)jarg1;
59016   {
59017     try {
59018       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59019     } catch (std::out_of_range& e) {
59020       {
59021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59022       };
59023     } catch (std::exception& e) {
59024       {
59025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59026       };
59027     } catch (Dali::DaliException e) {
59028       {
59029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59030       };
59031     } catch (...) {
59032       {
59033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59034       };
59035     }
59036   }
59037
59038   jresult = result;
59039   return jresult;
59040 }
59041
59042
59043 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59044   unsigned long jresult ;
59045   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59046   std::size_t result;
59047
59048   arg1 = (Dali::Signal< bool () > *)jarg1;
59049   {
59050     try {
59051       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59052     } catch (std::out_of_range& e) {
59053       {
59054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59055       };
59056     } catch (std::exception& e) {
59057       {
59058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59059       };
59060     } catch (Dali::DaliException e) {
59061       {
59062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59063       };
59064     } catch (...) {
59065       {
59066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59067       };
59068     }
59069   }
59070
59071   jresult = (unsigned long)result;
59072   return jresult;
59073 }
59074
59075
59076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59077   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59078   bool (*arg2)() = (bool (*)()) 0 ;
59079
59080   arg1 = (Dali::Signal< bool () > *)jarg1;
59081   arg2 = (bool (*)())jarg2;
59082   {
59083     try {
59084       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59085     } catch (std::out_of_range& e) {
59086       {
59087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59088       };
59089     } catch (std::exception& e) {
59090       {
59091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59092       };
59093     } catch (Dali::DaliException e) {
59094       {
59095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59096       };
59097     } catch (...) {
59098       {
59099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59100       };
59101     }
59102   }
59103
59104 }
59105
59106
59107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59108   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59109   bool (*arg2)() = (bool (*)()) 0 ;
59110
59111   arg1 = (Dali::Signal< bool () > *)jarg1;
59112   arg2 = (bool (*)())jarg2;
59113   {
59114     try {
59115       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59116     } catch (std::out_of_range& e) {
59117       {
59118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59119       };
59120     } catch (std::exception& e) {
59121       {
59122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59123       };
59124     } catch (Dali::DaliException e) {
59125       {
59126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59127       };
59128     } catch (...) {
59129       {
59130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59131       };
59132     }
59133   }
59134
59135 }
59136
59137
59138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59139   unsigned int jresult ;
59140   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59141   bool result;
59142
59143   arg1 = (Dali::Signal< bool () > *)jarg1;
59144   {
59145     try {
59146       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59147     } catch (std::out_of_range& e) {
59148       {
59149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59150       };
59151     } catch (std::exception& e) {
59152       {
59153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59154       };
59155     } catch (Dali::DaliException e) {
59156       {
59157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59158       };
59159     } catch (...) {
59160       {
59161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59162       };
59163     }
59164   }
59165
59166   jresult = result;
59167   return jresult;
59168 }
59169
59170
59171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59172   void * jresult ;
59173   Dali::Signal< bool () > *result = 0 ;
59174
59175   {
59176     try {
59177       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59178     } catch (std::out_of_range& e) {
59179       {
59180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59181       };
59182     } catch (std::exception& e) {
59183       {
59184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59185       };
59186     } catch (Dali::DaliException e) {
59187       {
59188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59189       };
59190     } catch (...) {
59191       {
59192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59193       };
59194     }
59195   }
59196
59197   jresult = (void *)result;
59198   return jresult;
59199 }
59200
59201
59202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59203   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59204
59205   arg1 = (Dali::Signal< bool () > *)jarg1;
59206   {
59207     try {
59208       delete arg1;
59209     } catch (std::out_of_range& e) {
59210       {
59211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59212       };
59213     } catch (std::exception& e) {
59214       {
59215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59216       };
59217     } catch (Dali::DaliException e) {
59218       {
59219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59220       };
59221     } catch (...) {
59222       {
59223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59224       };
59225     }
59226   }
59227
59228 }
59229
59230
59231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59232   int jresult ;
59233   int result;
59234
59235   {
59236     try {
59237       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59238     } catch (std::out_of_range& e) {
59239       {
59240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59241       };
59242     } catch (std::exception& e) {
59243       {
59244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59245       };
59246     } catch (Dali::DaliException e) {
59247       {
59248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59249       };
59250     } catch (...) {
59251       {
59252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59253       };
59254     }
59255   }
59256
59257   jresult = (int)result;
59258   return jresult;
59259 }
59260
59261
59262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59263   int jresult ;
59264   int result;
59265
59266   {
59267     try {
59268       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59269     } catch (std::out_of_range& e) {
59270       {
59271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59272       };
59273     } catch (std::exception& e) {
59274       {
59275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59276       };
59277     } catch (Dali::DaliException e) {
59278       {
59279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59280       };
59281     } catch (...) {
59282       {
59283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59284       };
59285     }
59286   }
59287
59288   jresult = (int)result;
59289   return jresult;
59290 }
59291
59292
59293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59294   int jresult ;
59295   int result;
59296
59297   {
59298     try {
59299       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59300     } catch (std::out_of_range& e) {
59301       {
59302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59303       };
59304     } catch (std::exception& e) {
59305       {
59306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59307       };
59308     } catch (Dali::DaliException e) {
59309       {
59310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59311       };
59312     } catch (...) {
59313       {
59314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59315       };
59316     }
59317   }
59318
59319   jresult = (int)result;
59320   return jresult;
59321 }
59322
59323
59324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59325   int jresult ;
59326   int result;
59327
59328   {
59329     try {
59330       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59331     } catch (std::out_of_range& e) {
59332       {
59333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59334       };
59335     } catch (std::exception& e) {
59336       {
59337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59338       };
59339     } catch (Dali::DaliException e) {
59340       {
59341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59342       };
59343     } catch (...) {
59344       {
59345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59346       };
59347     }
59348   }
59349
59350   jresult = (int)result;
59351   return jresult;
59352 }
59353
59354
59355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59356   int jresult ;
59357   int result;
59358
59359   {
59360     try {
59361       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59362     } catch (std::out_of_range& e) {
59363       {
59364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59365       };
59366     } catch (std::exception& e) {
59367       {
59368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59369       };
59370     } catch (Dali::DaliException e) {
59371       {
59372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59373       };
59374     } catch (...) {
59375       {
59376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59377       };
59378     }
59379   }
59380
59381   jresult = (int)result;
59382   return jresult;
59383 }
59384
59385
59386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59387   int jresult ;
59388   int result;
59389
59390   {
59391     try {
59392       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59393     } catch (std::out_of_range& e) {
59394       {
59395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59396       };
59397     } catch (std::exception& e) {
59398       {
59399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59400       };
59401     } catch (Dali::DaliException e) {
59402       {
59403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59404       };
59405     } catch (...) {
59406       {
59407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59408       };
59409     }
59410   }
59411
59412   jresult = (int)result;
59413   return jresult;
59414 }
59415
59416
59417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59418   int jresult ;
59419   int result;
59420
59421   {
59422     try {
59423       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59424     } catch (std::out_of_range& e) {
59425       {
59426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59427       };
59428     } catch (std::exception& e) {
59429       {
59430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59431       };
59432     } catch (Dali::DaliException e) {
59433       {
59434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59435       };
59436     } catch (...) {
59437       {
59438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59439       };
59440     }
59441   }
59442
59443   jresult = (int)result;
59444   return jresult;
59445 }
59446
59447
59448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59449   int jresult ;
59450   int result;
59451
59452   {
59453     try {
59454       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59455     } catch (std::out_of_range& e) {
59456       {
59457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59458       };
59459     } catch (std::exception& e) {
59460       {
59461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59462       };
59463     } catch (Dali::DaliException e) {
59464       {
59465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59466       };
59467     } catch (...) {
59468       {
59469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59470       };
59471     }
59472   }
59473
59474   jresult = (int)result;
59475   return jresult;
59476 }
59477
59478
59479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59480   int jresult ;
59481   int result;
59482
59483   {
59484     try {
59485       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59486     } catch (std::out_of_range& e) {
59487       {
59488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59489       };
59490     } catch (std::exception& e) {
59491       {
59492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59493       };
59494     } catch (Dali::DaliException e) {
59495       {
59496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59497       };
59498     } catch (...) {
59499       {
59500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59501       };
59502     }
59503   }
59504
59505   jresult = (int)result;
59506   return jresult;
59507 }
59508
59509
59510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59511   int jresult ;
59512   int result;
59513
59514   {
59515     try {
59516       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59517     } catch (std::out_of_range& e) {
59518       {
59519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59520       };
59521     } catch (std::exception& e) {
59522       {
59523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59524       };
59525     } catch (Dali::DaliException e) {
59526       {
59527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59528       };
59529     } catch (...) {
59530       {
59531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59532       };
59533     }
59534   }
59535
59536   jresult = (int)result;
59537   return jresult;
59538 }
59539
59540
59541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59542   int jresult ;
59543   int result;
59544
59545   {
59546     try {
59547       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59548     } catch (std::out_of_range& e) {
59549       {
59550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59551       };
59552     } catch (std::exception& e) {
59553       {
59554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59555       };
59556     } catch (Dali::DaliException e) {
59557       {
59558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59559       };
59560     } catch (...) {
59561       {
59562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59563       };
59564     }
59565   }
59566
59567   jresult = (int)result;
59568   return jresult;
59569 }
59570
59571
59572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59573   int jresult ;
59574   int result;
59575
59576   {
59577     try {
59578       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59579     } catch (std::out_of_range& e) {
59580       {
59581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59582       };
59583     } catch (std::exception& e) {
59584       {
59585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59586       };
59587     } catch (Dali::DaliException e) {
59588       {
59589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59590       };
59591     } catch (...) {
59592       {
59593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59594       };
59595     }
59596   }
59597
59598   jresult = (int)result;
59599   return jresult;
59600 }
59601
59602
59603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59604   int jresult ;
59605   int result;
59606
59607   {
59608     try {
59609       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59610     } catch (std::out_of_range& e) {
59611       {
59612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59613       };
59614     } catch (std::exception& e) {
59615       {
59616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59617       };
59618     } catch (Dali::DaliException e) {
59619       {
59620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59621       };
59622     } catch (...) {
59623       {
59624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59625       };
59626     }
59627   }
59628
59629   jresult = (int)result;
59630   return jresult;
59631 }
59632
59633
59634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59635   int jresult ;
59636   int result;
59637
59638   {
59639     try {
59640       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59641     } catch (std::out_of_range& e) {
59642       {
59643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59644       };
59645     } catch (std::exception& e) {
59646       {
59647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59648       };
59649     } catch (Dali::DaliException e) {
59650       {
59651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59652       };
59653     } catch (...) {
59654       {
59655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59656       };
59657     }
59658   }
59659
59660   jresult = (int)result;
59661   return jresult;
59662 }
59663
59664
59665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59666   int jresult ;
59667   int result;
59668
59669   {
59670     try {
59671       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59672     } catch (std::out_of_range& e) {
59673       {
59674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59675       };
59676     } catch (std::exception& e) {
59677       {
59678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59679       };
59680     } catch (Dali::DaliException e) {
59681       {
59682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59683       };
59684     } catch (...) {
59685       {
59686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59687       };
59688     }
59689   }
59690
59691   jresult = (int)result;
59692   return jresult;
59693 }
59694
59695
59696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59697   int jresult ;
59698   int result;
59699
59700   {
59701     try {
59702       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59703     } catch (std::out_of_range& e) {
59704       {
59705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59706       };
59707     } catch (std::exception& e) {
59708       {
59709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59710       };
59711     } catch (Dali::DaliException e) {
59712       {
59713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59714       };
59715     } catch (...) {
59716       {
59717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59718       };
59719     }
59720   }
59721
59722   jresult = (int)result;
59723   return jresult;
59724 }
59725
59726
59727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59728   int jresult ;
59729   int result;
59730
59731   {
59732     try {
59733       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59734     } catch (std::out_of_range& e) {
59735       {
59736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59737       };
59738     } catch (std::exception& e) {
59739       {
59740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59741       };
59742     } catch (Dali::DaliException e) {
59743       {
59744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59745       };
59746     } catch (...) {
59747       {
59748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59749       };
59750     }
59751   }
59752
59753   jresult = (int)result;
59754   return jresult;
59755 }
59756
59757
59758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59759   int jresult ;
59760   int result;
59761
59762   {
59763     try {
59764       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59765     } catch (std::out_of_range& e) {
59766       {
59767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59768       };
59769     } catch (std::exception& e) {
59770       {
59771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59772       };
59773     } catch (Dali::DaliException e) {
59774       {
59775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59776       };
59777     } catch (...) {
59778       {
59779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59780       };
59781     }
59782   }
59783
59784   jresult = (int)result;
59785   return jresult;
59786 }
59787
59788
59789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59790   int jresult ;
59791   int result;
59792
59793   {
59794     try {
59795       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59796     } catch (std::out_of_range& e) {
59797       {
59798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59799       };
59800     } catch (std::exception& e) {
59801       {
59802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59803       };
59804     } catch (Dali::DaliException e) {
59805       {
59806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59807       };
59808     } catch (...) {
59809       {
59810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59811       };
59812     }
59813   }
59814
59815   jresult = (int)result;
59816   return jresult;
59817 }
59818
59819
59820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59821   int jresult ;
59822   int result;
59823
59824   {
59825     try {
59826       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59827     } catch (std::out_of_range& e) {
59828       {
59829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59830       };
59831     } catch (std::exception& e) {
59832       {
59833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59834       };
59835     } catch (Dali::DaliException e) {
59836       {
59837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59838       };
59839     } catch (...) {
59840       {
59841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59842       };
59843     }
59844   }
59845
59846   jresult = (int)result;
59847   return jresult;
59848 }
59849
59850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59851   int jresult ;
59852   int result;
59853
59854   {
59855     try {
59856       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59857     } catch (std::out_of_range& e) {
59858       {
59859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59860       };
59861     } catch (std::exception& e) {
59862       {
59863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59864       };
59865     } catch (Dali::DaliException e) {
59866       {
59867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59868       };
59869     } catch (...) {
59870       {
59871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59872       };
59873     }
59874   }
59875
59876   jresult = (int)result;
59877   return jresult;
59878 }
59879
59880
59881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59882   int jresult ;
59883   int result;
59884   {
59885     try
59886     {
59887       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59888     } catch (std::out_of_range& e) {
59889       {
59890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59891       };
59892     } catch (std::exception& e) {
59893       {
59894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59895       };
59896     } catch (Dali::DaliException e) {
59897       {
59898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59899       };
59900     } catch (...) {
59901       {
59902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59903       };
59904     }
59905   }
59906
59907   jresult = (int)result;
59908   return jresult;
59909 }
59910
59911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59912   int jresult ;
59913   int result;
59914   {
59915     try
59916     {
59917       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59918     } catch (std::out_of_range& e) {
59919       {
59920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59921       };
59922     } catch (std::exception& e) {
59923       {
59924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59925       };
59926     } catch (Dali::DaliException e) {
59927       {
59928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59929       };
59930     } catch (...) {
59931       {
59932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59933       };
59934     }
59935   }
59936
59937   jresult = (int)result;
59938   return jresult;
59939 }
59940
59941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59942   int jresult ;
59943   int result;
59944   {
59945     try
59946     {
59947       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59948     } catch (std::out_of_range& e) {
59949       {
59950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59951       };
59952     } catch (std::exception& e) {
59953       {
59954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (Dali::DaliException e) {
59957       {
59958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59959       };
59960     } catch (...) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59963       };
59964     }
59965   }
59966
59967   jresult = (int)result;
59968   return jresult;
59969 }
59970
59971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59972   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59973 }
59974
59975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59976   int jresult ;
59977   int result;
59978   {
59979     try
59980     {
59981       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59982     } catch (std::out_of_range& e) {
59983       {
59984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59985       };
59986     } catch (std::exception& e) {
59987       {
59988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59989       };
59990     } catch (Dali::DaliException e) {
59991       {
59992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59993       };
59994     } catch (...) {
59995       {
59996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59997       };
59998     }
59999   }
60000
60001   jresult = (int)result;
60002   return jresult;
60003 }
60004
60005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60006   int jresult ;
60007   int result;
60008   {
60009     try
60010     {
60011       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60012     } catch (std::out_of_range& e) {
60013       {
60014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60015       };
60016     } catch (std::exception& e) {
60017       {
60018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60019       };
60020     } catch (Dali::DaliException e) {
60021       {
60022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60023       };
60024     } catch (...) {
60025       {
60026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60027       };
60028     }
60029   }
60030
60031   jresult = (int)result;
60032   return jresult;
60033 }
60034
60035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60036   int jresult ;
60037   int result;
60038
60039   {
60040     try {
60041       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60042     } catch (std::out_of_range& e) {
60043       {
60044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60045       };
60046     } catch (std::exception& e) {
60047       {
60048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60049       };
60050     } catch (Dali::DaliException e) {
60051       {
60052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60053       };
60054     } catch (...) {
60055       {
60056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60057       };
60058     }
60059   }
60060
60061   jresult = (int)result;
60062   return jresult;
60063 }
60064
60065
60066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60067   int jresult ;
60068   int result;
60069
60070   {
60071     try {
60072       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60073     } catch (std::out_of_range& e) {
60074       {
60075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60076       };
60077     } catch (std::exception& e) {
60078       {
60079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60080       };
60081     } catch (Dali::DaliException e) {
60082       {
60083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60084       };
60085     } catch (...) {
60086       {
60087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60088       };
60089     }
60090   }
60091
60092   jresult = (int)result;
60093   return jresult;
60094 }
60095
60096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60097   int jresult ;
60098   int result;
60099   {
60100     try
60101     {
60102       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60103     } catch (std::out_of_range& e) {
60104       {
60105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60106       };
60107     } catch (std::exception& e) {
60108       {
60109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60110       };
60111     } catch (...) {
60112       {
60113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60114       };
60115     }
60116   }
60117   jresult = (int)result;
60118   return jresult;
60119 }
60120
60121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60122   int jresult ;
60123   int result;
60124   {
60125     try
60126     {
60127       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60128     } catch (std::out_of_range& e) {
60129       {
60130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (std::exception& e) {
60133       {
60134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60135       };
60136     } catch (...) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60139       };
60140     }
60141   }
60142   jresult = (int)result;
60143   return jresult;
60144 }
60145
60146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60147   int jresult ;
60148   int result;
60149   {
60150     try
60151     {
60152       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60153     } catch (std::out_of_range& e) {
60154       {
60155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60156       };
60157     } catch (std::exception& e) {
60158       {
60159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60160       };
60161     } catch (...) {
60162       {
60163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60164       };
60165     }
60166   }
60167   jresult = (int)result;
60168   return jresult;
60169 }
60170
60171
60172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60173   int jresult ;
60174   int result;
60175   {
60176     try
60177     {
60178       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60186       };
60187     } catch (...) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60190       };
60191     }
60192   }
60193   jresult = (int)result;
60194   return jresult;
60195 }
60196
60197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60198   int jresult ;
60199   int result;
60200   {
60201     try
60202     {
60203       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60204     } catch (std::out_of_range& e) {
60205       {
60206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60207       };
60208     } catch (std::exception& e) {
60209       {
60210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60211       };
60212     } catch (...) {
60213       {
60214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60215       };
60216     }
60217   }
60218   jresult = (int)result;
60219   return jresult;
60220 }
60221
60222
60223
60224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60225   int jresult ;
60226   int result;
60227
60228   {
60229     try {
60230       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60231     } catch (std::out_of_range& e) {
60232       {
60233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60234       };
60235     } catch (std::exception& e) {
60236       {
60237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60238       };
60239     } catch (Dali::DaliException e) {
60240       {
60241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60242       };
60243     } catch (...) {
60244       {
60245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60246       };
60247     }
60248   }
60249
60250   jresult = (int)result;
60251   return jresult;
60252 }
60253
60254
60255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60256   int jresult ;
60257   int result;
60258
60259   {
60260     try {
60261       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60262     } catch (std::out_of_range& e) {
60263       {
60264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60265       };
60266     } catch (std::exception& e) {
60267       {
60268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60269       };
60270     } catch (Dali::DaliException e) {
60271       {
60272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60273       };
60274     } catch (...) {
60275       {
60276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60277       };
60278     }
60279   }
60280
60281   jresult = (int)result;
60282   return jresult;
60283 }
60284
60285
60286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60287   int jresult ;
60288   int result;
60289
60290   {
60291     try {
60292       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60293     } catch (std::out_of_range& e) {
60294       {
60295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60296       };
60297     } catch (std::exception& e) {
60298       {
60299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60300       };
60301     } catch (Dali::DaliException e) {
60302       {
60303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60304       };
60305     } catch (...) {
60306       {
60307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60308       };
60309     }
60310   }
60311
60312   jresult = (int)result;
60313   return jresult;
60314 }
60315
60316
60317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60318   int jresult ;
60319   int result;
60320
60321   {
60322     try {
60323       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60324     } catch (std::out_of_range& e) {
60325       {
60326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60327       };
60328     } catch (std::exception& e) {
60329       {
60330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60331       };
60332     } catch (Dali::DaliException e) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60335       };
60336     } catch (...) {
60337       {
60338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60339       };
60340     }
60341   }
60342
60343   jresult = (int)result;
60344   return jresult;
60345 }
60346
60347
60348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60349   int jresult ;
60350   int result;
60351
60352   {
60353     try {
60354       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60355     } catch (std::out_of_range& e) {
60356       {
60357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60358       };
60359     } catch (std::exception& e) {
60360       {
60361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60362       };
60363     } catch (Dali::DaliException e) {
60364       {
60365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60366       };
60367     } catch (...) {
60368       {
60369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60370       };
60371     }
60372   }
60373
60374   jresult = (int)result;
60375   return jresult;
60376 }
60377
60378
60379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60380   int jresult ;
60381   int result;
60382
60383   {
60384     try {
60385       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60386     } catch (std::out_of_range& e) {
60387       {
60388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60389       };
60390     } catch (std::exception& e) {
60391       {
60392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60393       };
60394     } catch (Dali::DaliException e) {
60395       {
60396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60397       };
60398     } catch (...) {
60399       {
60400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60401       };
60402     }
60403   }
60404
60405   jresult = (int)result;
60406   return jresult;
60407 }
60408
60409
60410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60411   int jresult ;
60412   int result;
60413
60414   {
60415     try {
60416       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60417     } catch (std::out_of_range& e) {
60418       {
60419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60420       };
60421     } catch (std::exception& e) {
60422       {
60423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60424       };
60425     } catch (Dali::DaliException e) {
60426       {
60427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60428       };
60429     } catch (...) {
60430       {
60431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60432       };
60433     }
60434   }
60435
60436   jresult = (int)result;
60437   return jresult;
60438 }
60439
60440 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60441   int jresult ;
60442   int result;
60443
60444   {
60445     try {
60446       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60447     } catch (std::out_of_range& e) {
60448       {
60449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60450       };
60451     } catch (std::exception& e) {
60452       {
60453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60454       };
60455     } catch (...) {
60456       {
60457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60458       };
60459     }
60460   }
60461   jresult = (int)result;
60462   return jresult;
60463 }
60464
60465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60466   int jresult ;
60467   int result;
60468
60469   {
60470     try {
60471       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60472     } catch (std::out_of_range& e) {
60473       {
60474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60475       };
60476     } catch (std::exception& e) {
60477       {
60478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60479       };
60480     } catch (Dali::DaliException e) {
60481       {
60482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60483       };
60484     } catch (...) {
60485       {
60486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60487       };
60488     }
60489   }
60490
60491   jresult = (int)result;
60492   return jresult;
60493 }
60494
60495
60496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60497   int jresult ;
60498   int result;
60499
60500   {
60501     try {
60502       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60503     } catch (std::out_of_range& e) {
60504       {
60505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60506       };
60507     } catch (std::exception& e) {
60508       {
60509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60510       };
60511     } catch (Dali::DaliException e) {
60512       {
60513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60514       };
60515     } catch (...) {
60516       {
60517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60518       };
60519     }
60520   }
60521
60522   jresult = (int)result;
60523   return jresult;
60524 }
60525
60526
60527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60528   int jresult ;
60529   int result;
60530
60531   {
60532     try {
60533       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60534     } catch (std::out_of_range& e) {
60535       {
60536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60537       };
60538     } catch (std::exception& e) {
60539       {
60540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60541       };
60542     } catch (Dali::DaliException e) {
60543       {
60544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60545       };
60546     } catch (...) {
60547       {
60548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60549       };
60550     }
60551   }
60552
60553   jresult = (int)result;
60554   return jresult;
60555 }
60556
60557
60558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60559   int jresult ;
60560   int result;
60561
60562   {
60563     try {
60564       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60565     } catch (std::out_of_range& e) {
60566       {
60567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60568       };
60569     } catch (std::exception& e) {
60570       {
60571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60572       };
60573     } catch (Dali::DaliException e) {
60574       {
60575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60576       };
60577     } catch (...) {
60578       {
60579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60580       };
60581     }
60582   }
60583
60584   jresult = (int)result;
60585   return jresult;
60586 }
60587
60588
60589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60590   int jresult ;
60591   int result;
60592
60593   {
60594     try {
60595       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60596     } catch (std::out_of_range& e) {
60597       {
60598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60599       };
60600     } catch (std::exception& e) {
60601       {
60602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60603       };
60604     } catch (Dali::DaliException e) {
60605       {
60606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60607       };
60608     } catch (...) {
60609       {
60610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60611       };
60612     }
60613   }
60614
60615   jresult = (int)result;
60616   return jresult;
60617 }
60618
60619
60620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60621   int jresult ;
60622   int result;
60623
60624   {
60625     try {
60626       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60627     } catch (std::out_of_range& e) {
60628       {
60629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60630       };
60631     } catch (std::exception& e) {
60632       {
60633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60634       };
60635     } catch (Dali::DaliException e) {
60636       {
60637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60638       };
60639     } catch (...) {
60640       {
60641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60642       };
60643     }
60644   }
60645
60646   jresult = (int)result;
60647   return jresult;
60648 }
60649
60650
60651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60652   int jresult ;
60653   int result;
60654
60655   {
60656     try {
60657       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60658     } catch (std::out_of_range& e) {
60659       {
60660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60661       };
60662     } catch (std::exception& e) {
60663       {
60664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60665       };
60666     } catch (Dali::DaliException e) {
60667       {
60668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60669       };
60670     } catch (...) {
60671       {
60672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60673       };
60674     }
60675   }
60676
60677   jresult = (int)result;
60678   return jresult;
60679 }
60680
60681
60682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60683   int jresult ;
60684   int result;
60685
60686   {
60687     try {
60688       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60689     } catch (std::out_of_range& e) {
60690       {
60691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60692       };
60693     } catch (std::exception& e) {
60694       {
60695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60696       };
60697     } catch (Dali::DaliException e) {
60698       {
60699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60700       };
60701     } catch (...) {
60702       {
60703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60704       };
60705     }
60706   }
60707
60708   jresult = (int)result;
60709   return jresult;
60710 }
60711
60712
60713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60714   int jresult ;
60715   int result;
60716
60717   {
60718     try {
60719       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60720     } catch (std::out_of_range& e) {
60721       {
60722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60723       };
60724     } catch (std::exception& e) {
60725       {
60726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60727       };
60728     } catch (Dali::DaliException e) {
60729       {
60730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60731       };
60732     } catch (...) {
60733       {
60734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60735       };
60736     }
60737   }
60738
60739   jresult = (int)result;
60740   return jresult;
60741 }
60742
60743
60744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60745   int jresult ;
60746   int result;
60747
60748   {
60749     try {
60750       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60751     } catch (std::out_of_range& e) {
60752       {
60753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60754       };
60755     } catch (std::exception& e) {
60756       {
60757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60758       };
60759     } catch (Dali::DaliException e) {
60760       {
60761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60762       };
60763     } catch (...) {
60764       {
60765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60766       };
60767     }
60768   }
60769
60770   jresult = (int)result;
60771   return jresult;
60772 }
60773
60774
60775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60776   int jresult ;
60777   int result;
60778
60779   {
60780     try {
60781       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60782     } catch (std::out_of_range& e) {
60783       {
60784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60785       };
60786     } catch (std::exception& e) {
60787       {
60788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60789       };
60790     } catch (Dali::DaliException e) {
60791       {
60792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60793       };
60794     } catch (...) {
60795       {
60796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60797       };
60798     }
60799   }
60800
60801   jresult = (int)result;
60802   return jresult;
60803 }
60804
60805
60806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60807   int jresult ;
60808   int result;
60809
60810   {
60811     try {
60812       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60813     } catch (std::out_of_range& e) {
60814       {
60815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60816       };
60817     } catch (std::exception& e) {
60818       {
60819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60820       };
60821     } catch (Dali::DaliException e) {
60822       {
60823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60824       };
60825     } catch (...) {
60826       {
60827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60828       };
60829     }
60830   }
60831
60832   jresult = (int)result;
60833   return jresult;
60834 }
60835
60836
60837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60838   int jresult ;
60839   int result;
60840
60841   {
60842     try {
60843       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60844     } catch (std::out_of_range& e) {
60845       {
60846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60847       };
60848     } catch (std::exception& e) {
60849       {
60850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60851       };
60852     } catch (Dali::DaliException e) {
60853       {
60854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60855       };
60856     } catch (...) {
60857       {
60858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60859       };
60860     }
60861   }
60862
60863   jresult = (int)result;
60864   return jresult;
60865 }
60866
60867
60868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60869   int jresult ;
60870   int result;
60871
60872   {
60873     try {
60874       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60875     } catch (std::out_of_range& e) {
60876       {
60877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60878       };
60879     } catch (std::exception& e) {
60880       {
60881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60882       };
60883     } catch (Dali::DaliException e) {
60884       {
60885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60886       };
60887     } catch (...) {
60888       {
60889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60890       };
60891     }
60892   }
60893
60894   jresult = (int)result;
60895   return jresult;
60896 }
60897
60898
60899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60900   int jresult ;
60901   int result;
60902
60903   {
60904     try {
60905       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60906     } catch (std::out_of_range& e) {
60907       {
60908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60909       };
60910     } catch (std::exception& e) {
60911       {
60912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60913       };
60914     } catch (Dali::DaliException e) {
60915       {
60916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60917       };
60918     } catch (...) {
60919       {
60920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60921       };
60922     }
60923   }
60924
60925   jresult = (int)result;
60926   return jresult;
60927 }
60928
60929
60930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60931   int jresult ;
60932   int result;
60933
60934   {
60935     try {
60936       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60937     } catch (std::out_of_range& e) {
60938       {
60939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60940       };
60941     } catch (std::exception& e) {
60942       {
60943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60944       };
60945     } catch (Dali::DaliException e) {
60946       {
60947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60948       };
60949     } catch (...) {
60950       {
60951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60952       };
60953     }
60954   }
60955
60956   jresult = (int)result;
60957   return jresult;
60958 }
60959
60960
60961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60962   int jresult ;
60963   int result;
60964
60965   {
60966     try {
60967       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60968     } catch (std::out_of_range& e) {
60969       {
60970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60971       };
60972     } catch (std::exception& e) {
60973       {
60974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60975       };
60976     } catch (Dali::DaliException e) {
60977       {
60978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60979       };
60980     } catch (...) {
60981       {
60982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60983       };
60984     }
60985   }
60986
60987   jresult = (int)result;
60988   return jresult;
60989 }
60990
60991
60992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60993   int jresult ;
60994   int result;
60995
60996   {
60997     try {
60998       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60999     } catch (std::out_of_range& e) {
61000       {
61001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61002       };
61003     } catch (std::exception& e) {
61004       {
61005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61006       };
61007     } catch (Dali::DaliException e) {
61008       {
61009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61010       };
61011     } catch (...) {
61012       {
61013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61014       };
61015     }
61016   }
61017
61018   jresult = (int)result;
61019   return jresult;
61020 }
61021
61022
61023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61024   int jresult ;
61025   int result;
61026
61027   {
61028     try {
61029       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61030     } catch (std::out_of_range& e) {
61031       {
61032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61033       };
61034     } catch (std::exception& e) {
61035       {
61036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61037       };
61038     } catch (Dali::DaliException e) {
61039       {
61040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61041       };
61042     } catch (...) {
61043       {
61044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61045       };
61046     }
61047   }
61048
61049   jresult = (int)result;
61050   return jresult;
61051 }
61052
61053
61054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61055   int jresult ;
61056   int result;
61057
61058   {
61059     try {
61060       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61061     } catch (std::out_of_range& e) {
61062       {
61063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61064       };
61065     } catch (std::exception& e) {
61066       {
61067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61068       };
61069     } catch (Dali::DaliException e) {
61070       {
61071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61072       };
61073     } catch (...) {
61074       {
61075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61076       };
61077     }
61078   }
61079
61080   jresult = (int)result;
61081   return jresult;
61082 }
61083
61084
61085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61086   int jresult ;
61087   int result;
61088
61089   {
61090     try {
61091       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61092     } catch (std::out_of_range& e) {
61093       {
61094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61095       };
61096     } catch (std::exception& e) {
61097       {
61098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61099       };
61100     } catch (Dali::DaliException e) {
61101       {
61102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61103       };
61104     } catch (...) {
61105       {
61106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61107       };
61108     }
61109   }
61110
61111   jresult = (int)result;
61112   return jresult;
61113 }
61114
61115
61116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61117   int jresult ;
61118   int result;
61119
61120   {
61121     try {
61122       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61123     } catch (std::out_of_range& e) {
61124       {
61125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61126       };
61127     } catch (std::exception& e) {
61128       {
61129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61130       };
61131     } catch (Dali::DaliException e) {
61132       {
61133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61134       };
61135     } catch (...) {
61136       {
61137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61138       };
61139     }
61140   }
61141
61142   jresult = (int)result;
61143   return jresult;
61144 }
61145
61146
61147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61148   int jresult ;
61149   int result;
61150
61151   {
61152     try {
61153       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61154     } catch (std::out_of_range& e) {
61155       {
61156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61157       };
61158     } catch (std::exception& e) {
61159       {
61160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61161       };
61162     } catch (Dali::DaliException e) {
61163       {
61164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61165       };
61166     } catch (...) {
61167       {
61168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61169       };
61170     }
61171   }
61172
61173   jresult = (int)result;
61174   return jresult;
61175 }
61176
61177
61178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61179   int jresult ;
61180   int result;
61181
61182   {
61183     try {
61184       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61185     } catch (std::out_of_range& e) {
61186       {
61187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61188       };
61189     } catch (std::exception& e) {
61190       {
61191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61192       };
61193     } catch (Dali::DaliException e) {
61194       {
61195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61196       };
61197     } catch (...) {
61198       {
61199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61200       };
61201     }
61202   }
61203
61204   jresult = (int)result;
61205   return jresult;
61206 }
61207
61208
61209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61210   int jresult ;
61211   int result;
61212
61213   {
61214     try {
61215       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61216     } catch (std::out_of_range& e) {
61217       {
61218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61219       };
61220     } catch (std::exception& e) {
61221       {
61222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61223       };
61224     } catch (Dali::DaliException e) {
61225       {
61226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61227       };
61228     } catch (...) {
61229       {
61230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61231       };
61232     }
61233   }
61234
61235   jresult = (int)result;
61236   return jresult;
61237 }
61238
61239
61240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61241   int jresult ;
61242   int result;
61243
61244   {
61245     try {
61246       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61247     } catch (std::out_of_range& e) {
61248       {
61249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61250       };
61251     } catch (std::exception& e) {
61252       {
61253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61254       };
61255     } catch (Dali::DaliException e) {
61256       {
61257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61258       };
61259     } catch (...) {
61260       {
61261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61262       };
61263     }
61264   }
61265
61266   jresult = (int)result;
61267   return jresult;
61268 }
61269
61270
61271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61272   int jresult ;
61273   int result;
61274
61275   {
61276     try {
61277       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61278     } catch (std::out_of_range& e) {
61279       {
61280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61281       };
61282     } catch (std::exception& e) {
61283       {
61284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61285       };
61286     } catch (Dali::DaliException e) {
61287       {
61288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61289       };
61290     } catch (...) {
61291       {
61292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61293       };
61294     }
61295   }
61296
61297   jresult = (int)result;
61298   return jresult;
61299 }
61300
61301
61302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61303   int jresult ;
61304   int result;
61305
61306   {
61307     try {
61308       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61309     } catch (std::out_of_range& e) {
61310       {
61311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61312       };
61313     } catch (std::exception& e) {
61314       {
61315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61316       };
61317     } catch (Dali::DaliException e) {
61318       {
61319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61320       };
61321     } catch (...) {
61322       {
61323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61324       };
61325     }
61326   }
61327
61328   jresult = (int)result;
61329   return jresult;
61330 }
61331
61332
61333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61334   void * jresult ;
61335   Dali::Toolkit::Builder *result = 0 ;
61336
61337   {
61338     try {
61339       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61340     } catch (std::out_of_range& e) {
61341       {
61342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61343       };
61344     } catch (std::exception& e) {
61345       {
61346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61347       };
61348     } catch (Dali::DaliException e) {
61349       {
61350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61351       };
61352     } catch (...) {
61353       {
61354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61355       };
61356     }
61357   }
61358
61359   jresult = (void *)result;
61360   return jresult;
61361 }
61362
61363
61364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61365   void * jresult ;
61366   Dali::Toolkit::Builder result;
61367
61368   {
61369     try {
61370       result = Dali::Toolkit::Builder::New();
61371     } catch (std::out_of_range& e) {
61372       {
61373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61374       };
61375     } catch (std::exception& e) {
61376       {
61377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61378       };
61379     } catch (Dali::DaliException e) {
61380       {
61381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61382       };
61383     } catch (...) {
61384       {
61385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61386       };
61387     }
61388   }
61389
61390   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61391   return jresult;
61392 }
61393
61394
61395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61396   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61397
61398   arg1 = (Dali::Toolkit::Builder *)jarg1;
61399   {
61400     try {
61401       delete arg1;
61402     } catch (std::out_of_range& e) {
61403       {
61404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61405       };
61406     } catch (std::exception& e) {
61407       {
61408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61409       };
61410     } catch (Dali::DaliException e) {
61411       {
61412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61413       };
61414     } catch (...) {
61415       {
61416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61417       };
61418     }
61419   }
61420
61421 }
61422
61423
61424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61425   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61426   std::string *arg2 = 0 ;
61427   Dali::Toolkit::Builder::UIFormat arg3 ;
61428
61429   arg1 = (Dali::Toolkit::Builder *)jarg1;
61430   if (!jarg2) {
61431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61432     return ;
61433   }
61434   std::string arg2_str(jarg2);
61435   arg2 = &arg2_str;
61436   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61437   {
61438     try {
61439       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61440     } catch (std::out_of_range& e) {
61441       {
61442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61443       };
61444     } catch (std::exception& e) {
61445       {
61446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61447       };
61448     } catch (Dali::DaliException e) {
61449       {
61450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61451       };
61452     } catch (...) {
61453       {
61454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61455       };
61456     }
61457   }
61458
61459
61460   //argout typemap for const std::string&
61461
61462 }
61463
61464
61465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61466   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61467   std::string *arg2 = 0 ;
61468
61469   arg1 = (Dali::Toolkit::Builder *)jarg1;
61470   if (!jarg2) {
61471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61472     return ;
61473   }
61474   std::string arg2_str(jarg2);
61475   arg2 = &arg2_str;
61476   {
61477     try {
61478       (arg1)->LoadFromString((std::string const &)*arg2);
61479     } catch (std::out_of_range& e) {
61480       {
61481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61482       };
61483     } catch (std::exception& e) {
61484       {
61485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61486       };
61487     } catch (Dali::DaliException e) {
61488       {
61489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61490       };
61491     } catch (...) {
61492       {
61493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61494       };
61495     }
61496   }
61497
61498
61499   //argout typemap for const std::string&
61500
61501 }
61502
61503
61504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61505   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61506   Dali::Property::Map *arg2 = 0 ;
61507
61508   arg1 = (Dali::Toolkit::Builder *)jarg1;
61509   arg2 = (Dali::Property::Map *)jarg2;
61510   if (!arg2) {
61511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61512     return ;
61513   }
61514   {
61515     try {
61516       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61517     } catch (std::out_of_range& e) {
61518       {
61519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61520       };
61521     } catch (std::exception& e) {
61522       {
61523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61524       };
61525     } catch (Dali::DaliException e) {
61526       {
61527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61528       };
61529     } catch (...) {
61530       {
61531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61532       };
61533     }
61534   }
61535
61536 }
61537
61538
61539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61540   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61541   std::string *arg2 = 0 ;
61542   Dali::Property::Value *arg3 = 0 ;
61543
61544   arg1 = (Dali::Toolkit::Builder *)jarg1;
61545   if (!jarg2) {
61546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61547     return ;
61548   }
61549   std::string arg2_str(jarg2);
61550   arg2 = &arg2_str;
61551   arg3 = (Dali::Property::Value *)jarg3;
61552   if (!arg3) {
61553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61554     return ;
61555   }
61556   {
61557     try {
61558       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61559     } catch (std::out_of_range& e) {
61560       {
61561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61562       };
61563     } catch (std::exception& e) {
61564       {
61565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61566       };
61567     } catch (Dali::DaliException e) {
61568       {
61569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61570       };
61571     } catch (...) {
61572       {
61573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61574       };
61575     }
61576   }
61577
61578
61579   //argout typemap for const std::string&
61580
61581 }
61582
61583
61584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61585   void * jresult ;
61586   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61587   Dali::Property::Map *result = 0 ;
61588
61589   arg1 = (Dali::Toolkit::Builder *)jarg1;
61590   {
61591     try {
61592       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61593     } catch (std::out_of_range& e) {
61594       {
61595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61596       };
61597     } catch (std::exception& e) {
61598       {
61599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61600       };
61601     } catch (Dali::DaliException e) {
61602       {
61603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61604       };
61605     } catch (...) {
61606       {
61607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61608       };
61609     }
61610   }
61611
61612   jresult = (void *)result;
61613   return jresult;
61614 }
61615
61616
61617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61618   void * jresult ;
61619   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61620   std::string *arg2 = 0 ;
61621   Dali::Property::Value *result = 0 ;
61622
61623   arg1 = (Dali::Toolkit::Builder *)jarg1;
61624   if (!jarg2) {
61625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61626     return 0;
61627   }
61628   std::string arg2_str(jarg2);
61629   arg2 = &arg2_str;
61630   {
61631     try {
61632       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61633     } catch (std::out_of_range& e) {
61634       {
61635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61636       };
61637     } catch (std::exception& e) {
61638       {
61639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61640       };
61641     } catch (Dali::DaliException e) {
61642       {
61643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61644       };
61645     } catch (...) {
61646       {
61647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61648       };
61649     }
61650   }
61651
61652   jresult = (void *)result;
61653
61654   //argout typemap for const std::string&
61655
61656   return jresult;
61657 }
61658
61659
61660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61661   void * jresult ;
61662   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61663   std::string *arg2 = 0 ;
61664   Dali::Animation result;
61665
61666   arg1 = (Dali::Toolkit::Builder *)jarg1;
61667   if (!jarg2) {
61668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61669     return 0;
61670   }
61671   std::string arg2_str(jarg2);
61672   arg2 = &arg2_str;
61673   {
61674     try {
61675       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61676     } catch (std::out_of_range& e) {
61677       {
61678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61679       };
61680     } catch (std::exception& e) {
61681       {
61682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61683       };
61684     } catch (Dali::DaliException e) {
61685       {
61686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61687       };
61688     } catch (...) {
61689       {
61690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61691       };
61692     }
61693   }
61694
61695   jresult = new Dali::Animation((const Dali::Animation &)result);
61696
61697   //argout typemap for const std::string&
61698
61699   return jresult;
61700 }
61701
61702
61703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61704   void * jresult ;
61705   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61706   std::string *arg2 = 0 ;
61707   Dali::Property::Map *arg3 = 0 ;
61708   Dali::Animation result;
61709
61710   arg1 = (Dali::Toolkit::Builder *)jarg1;
61711   if (!jarg2) {
61712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61713     return 0;
61714   }
61715   std::string arg2_str(jarg2);
61716   arg2 = &arg2_str;
61717   arg3 = (Dali::Property::Map *)jarg3;
61718   if (!arg3) {
61719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61720     return 0;
61721   }
61722   {
61723     try {
61724       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61725     } catch (std::out_of_range& e) {
61726       {
61727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61728       };
61729     } catch (std::exception& e) {
61730       {
61731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61732       };
61733     } catch (Dali::DaliException e) {
61734       {
61735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61736       };
61737     } catch (...) {
61738       {
61739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61740       };
61741     }
61742   }
61743
61744   jresult = new Dali::Animation((const Dali::Animation &)result);
61745
61746   //argout typemap for const std::string&
61747
61748   return jresult;
61749 }
61750
61751
61752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61753   void * jresult ;
61754   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61755   std::string *arg2 = 0 ;
61756   Dali::Actor arg3 ;
61757   Dali::Actor *argp3 ;
61758   Dali::Animation result;
61759
61760   arg1 = (Dali::Toolkit::Builder *)jarg1;
61761   if (!jarg2) {
61762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61763     return 0;
61764   }
61765   std::string arg2_str(jarg2);
61766   arg2 = &arg2_str;
61767   argp3 = (Dali::Actor *)jarg3;
61768   if (!argp3) {
61769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61770     return 0;
61771   }
61772   arg3 = *argp3;
61773   {
61774     try {
61775       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61776     } catch (std::out_of_range& e) {
61777       {
61778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61779       };
61780     } catch (std::exception& e) {
61781       {
61782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61783       };
61784     } catch (Dali::DaliException e) {
61785       {
61786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61787       };
61788     } catch (...) {
61789       {
61790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61791       };
61792     }
61793   }
61794
61795   jresult = new Dali::Animation((const Dali::Animation &)result);
61796
61797   //argout typemap for const std::string&
61798
61799   return jresult;
61800 }
61801
61802
61803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61804   void * jresult ;
61805   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61806   std::string *arg2 = 0 ;
61807   Dali::Property::Map *arg3 = 0 ;
61808   Dali::Actor arg4 ;
61809   Dali::Actor *argp4 ;
61810   Dali::Animation result;
61811
61812   arg1 = (Dali::Toolkit::Builder *)jarg1;
61813   if (!jarg2) {
61814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61815     return 0;
61816   }
61817   std::string arg2_str(jarg2);
61818   arg2 = &arg2_str;
61819   arg3 = (Dali::Property::Map *)jarg3;
61820   if (!arg3) {
61821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61822     return 0;
61823   }
61824   argp4 = (Dali::Actor *)jarg4;
61825   if (!argp4) {
61826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61827     return 0;
61828   }
61829   arg4 = *argp4;
61830   {
61831     try {
61832       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61833     } catch (std::out_of_range& e) {
61834       {
61835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61836       };
61837     } catch (std::exception& e) {
61838       {
61839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61840       };
61841     } catch (Dali::DaliException e) {
61842       {
61843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61844       };
61845     } catch (...) {
61846       {
61847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61848       };
61849     }
61850   }
61851
61852   jresult = new Dali::Animation((const Dali::Animation &)result);
61853
61854   //argout typemap for const std::string&
61855
61856   return jresult;
61857 }
61858
61859
61860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61861   void * jresult ;
61862   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61863   std::string *arg2 = 0 ;
61864   Dali::BaseHandle result;
61865
61866   arg1 = (Dali::Toolkit::Builder *)jarg1;
61867   if (!jarg2) {
61868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61869     return 0;
61870   }
61871   std::string arg2_str(jarg2);
61872   arg2 = &arg2_str;
61873   {
61874     try {
61875       result = (arg1)->Create((std::string const &)*arg2);
61876     } catch (std::out_of_range& e) {
61877       {
61878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61879       };
61880     } catch (std::exception& e) {
61881       {
61882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61883       };
61884     } catch (Dali::DaliException e) {
61885       {
61886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61887       };
61888     } catch (...) {
61889       {
61890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61891       };
61892     }
61893   }
61894
61895   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61896
61897   //argout typemap for const std::string&
61898
61899   return jresult;
61900 }
61901
61902
61903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61904   void * jresult ;
61905   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61906   std::string *arg2 = 0 ;
61907   Dali::Property::Map *arg3 = 0 ;
61908   Dali::BaseHandle result;
61909
61910   arg1 = (Dali::Toolkit::Builder *)jarg1;
61911   if (!jarg2) {
61912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61913     return 0;
61914   }
61915   std::string arg2_str(jarg2);
61916   arg2 = &arg2_str;
61917   arg3 = (Dali::Property::Map *)jarg3;
61918   if (!arg3) {
61919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61920     return 0;
61921   }
61922   {
61923     try {
61924       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61925     } catch (std::out_of_range& e) {
61926       {
61927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61928       };
61929     } catch (std::exception& e) {
61930       {
61931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61932       };
61933     } catch (Dali::DaliException e) {
61934       {
61935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61936       };
61937     } catch (...) {
61938       {
61939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61940       };
61941     }
61942   }
61943
61944   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61945
61946   //argout typemap for const std::string&
61947
61948   return jresult;
61949 }
61950
61951
61952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61953   void * jresult ;
61954   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61955   std::string *arg2 = 0 ;
61956   Dali::BaseHandle result;
61957
61958   arg1 = (Dali::Toolkit::Builder *)jarg1;
61959   if (!jarg2) {
61960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61961     return 0;
61962   }
61963   std::string arg2_str(jarg2);
61964   arg2 = &arg2_str;
61965   {
61966     try {
61967       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61968     } catch (std::out_of_range& e) {
61969       {
61970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61971       };
61972     } catch (std::exception& e) {
61973       {
61974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61975       };
61976     } catch (Dali::DaliException e) {
61977       {
61978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61979       };
61980     } catch (...) {
61981       {
61982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61983       };
61984     }
61985   }
61986
61987   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61988
61989   //argout typemap for const std::string&
61990
61991   return jresult;
61992 }
61993
61994
61995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61996   unsigned int jresult ;
61997   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61998   std::string *arg2 = 0 ;
61999   Dali::Handle *arg3 = 0 ;
62000   bool result;
62001
62002   arg1 = (Dali::Toolkit::Builder *)jarg1;
62003   if (!jarg2) {
62004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62005     return 0;
62006   }
62007   std::string arg2_str(jarg2);
62008   arg2 = &arg2_str;
62009   arg3 = (Dali::Handle *)jarg3;
62010   if (!arg3) {
62011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62012     return 0;
62013   }
62014   {
62015     try {
62016       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62017     } catch (std::out_of_range& e) {
62018       {
62019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62020       };
62021     } catch (std::exception& e) {
62022       {
62023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62024       };
62025     } catch (Dali::DaliException e) {
62026       {
62027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62028       };
62029     } catch (...) {
62030       {
62031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62032       };
62033     }
62034   }
62035
62036   jresult = result;
62037
62038   //argout typemap for const std::string&
62039
62040   return jresult;
62041 }
62042
62043
62044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62045   unsigned int jresult ;
62046   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62047   Dali::Handle *arg2 = 0 ;
62048   std::string *arg3 = 0 ;
62049   bool result;
62050
62051   arg1 = (Dali::Toolkit::Builder *)jarg1;
62052   arg2 = (Dali::Handle *)jarg2;
62053   if (!arg2) {
62054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62055     return 0;
62056   }
62057   if (!jarg3) {
62058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62059     return 0;
62060   }
62061   std::string arg3_str(jarg3);
62062   arg3 = &arg3_str;
62063   {
62064     try {
62065       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62066     } catch (std::out_of_range& e) {
62067       {
62068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62069       };
62070     } catch (std::exception& e) {
62071       {
62072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62073       };
62074     } catch (Dali::DaliException e) {
62075       {
62076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62077       };
62078     } catch (...) {
62079       {
62080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62081       };
62082     }
62083   }
62084
62085   jresult = result;
62086
62087   //argout typemap for const std::string&
62088
62089   return jresult;
62090 }
62091
62092
62093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62094   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62095   Dali::Actor arg2 ;
62096   Dali::Actor *argp2 ;
62097
62098   arg1 = (Dali::Toolkit::Builder *)jarg1;
62099   argp2 = (Dali::Actor *)jarg2;
62100   if (!argp2) {
62101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62102     return ;
62103   }
62104   arg2 = *argp2;
62105   {
62106     try {
62107       (arg1)->AddActors(arg2);
62108     } catch (std::out_of_range& e) {
62109       {
62110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62111       };
62112     } catch (std::exception& e) {
62113       {
62114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62115       };
62116     } catch (Dali::DaliException e) {
62117       {
62118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62119       };
62120     } catch (...) {
62121       {
62122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62123       };
62124     }
62125   }
62126
62127 }
62128
62129
62130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62131   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62132   std::string *arg2 = 0 ;
62133   Dali::Actor arg3 ;
62134   Dali::Actor *argp3 ;
62135
62136   arg1 = (Dali::Toolkit::Builder *)jarg1;
62137   if (!jarg2) {
62138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62139     return ;
62140   }
62141   std::string arg2_str(jarg2);
62142   arg2 = &arg2_str;
62143   argp3 = (Dali::Actor *)jarg3;
62144   if (!argp3) {
62145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62146     return ;
62147   }
62148   arg3 = *argp3;
62149   {
62150     try {
62151       (arg1)->AddActors((std::string const &)*arg2,arg3);
62152     } catch (std::out_of_range& e) {
62153       {
62154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62155       };
62156     } catch (std::exception& e) {
62157       {
62158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62159       };
62160     } catch (Dali::DaliException e) {
62161       {
62162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62163       };
62164     } catch (...) {
62165       {
62166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62167       };
62168     }
62169   }
62170
62171
62172   //argout typemap for const std::string&
62173
62174 }
62175
62176
62177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62178   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62179   std::string *arg2 = 0 ;
62180
62181   arg1 = (Dali::Toolkit::Builder *)jarg1;
62182   if (!jarg2) {
62183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62184     return ;
62185   }
62186   std::string arg2_str(jarg2);
62187   arg2 = &arg2_str;
62188   {
62189     try {
62190       (arg1)->CreateRenderTask((std::string const &)*arg2);
62191     } catch (std::out_of_range& e) {
62192       {
62193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62194       };
62195     } catch (std::exception& e) {
62196       {
62197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62198       };
62199     } catch (Dali::DaliException e) {
62200       {
62201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62202       };
62203     } catch (...) {
62204       {
62205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62206       };
62207     }
62208   }
62209
62210
62211   //argout typemap for const std::string&
62212
62213 }
62214
62215
62216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62217   void * jresult ;
62218   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62219   std::string *arg2 = 0 ;
62220   Dali::FrameBufferImage result;
62221
62222   arg1 = (Dali::Toolkit::Builder *)jarg1;
62223   if (!jarg2) {
62224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62225     return 0;
62226   }
62227   std::string arg2_str(jarg2);
62228   arg2 = &arg2_str;
62229   {
62230     try {
62231       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62232     } catch (std::out_of_range& e) {
62233       {
62234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62235       };
62236     } catch (std::exception& e) {
62237       {
62238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62239       };
62240     } catch (Dali::DaliException e) {
62241       {
62242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62243       };
62244     } catch (...) {
62245       {
62246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62247       };
62248     }
62249   }
62250
62251   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62252
62253   //argout typemap for const std::string&
62254
62255   return jresult;
62256 }
62257
62258
62259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62260   void * jresult ;
62261   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62262   std::string *arg2 = 0 ;
62263   Dali::Path result;
62264
62265   arg1 = (Dali::Toolkit::Builder *)jarg1;
62266   if (!jarg2) {
62267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62268     return 0;
62269   }
62270   std::string arg2_str(jarg2);
62271   arg2 = &arg2_str;
62272   {
62273     try {
62274       result = (arg1)->GetPath((std::string const &)*arg2);
62275     } catch (std::out_of_range& e) {
62276       {
62277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62278       };
62279     } catch (std::exception& e) {
62280       {
62281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62282       };
62283     } catch (Dali::DaliException e) {
62284       {
62285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62286       };
62287     } catch (...) {
62288       {
62289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62290       };
62291     }
62292   }
62293
62294   jresult = new Dali::Path((const Dali::Path &)result);
62295
62296   //argout typemap for const std::string&
62297
62298   return jresult;
62299 }
62300
62301
62302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62303   void * jresult ;
62304   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62305   std::string *arg2 = 0 ;
62306   Dali::PathConstrainer result;
62307
62308   arg1 = (Dali::Toolkit::Builder *)jarg1;
62309   if (!jarg2) {
62310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62311     return 0;
62312   }
62313   std::string arg2_str(jarg2);
62314   arg2 = &arg2_str;
62315   {
62316     try {
62317       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62318     } catch (std::out_of_range& e) {
62319       {
62320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (std::exception& e) {
62323       {
62324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62325       };
62326     } catch (Dali::DaliException e) {
62327       {
62328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62329       };
62330     } catch (...) {
62331       {
62332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62333       };
62334     }
62335   }
62336
62337   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62338
62339   //argout typemap for const std::string&
62340
62341   return jresult;
62342 }
62343
62344
62345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62346   void * jresult ;
62347   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62348   std::string *arg2 = 0 ;
62349   Dali::LinearConstrainer result;
62350
62351   arg1 = (Dali::Toolkit::Builder *)jarg1;
62352   if (!jarg2) {
62353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62354     return 0;
62355   }
62356   std::string arg2_str(jarg2);
62357   arg2 = &arg2_str;
62358   {
62359     try {
62360       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62361     } catch (std::out_of_range& e) {
62362       {
62363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62364       };
62365     } catch (std::exception& e) {
62366       {
62367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62368       };
62369     } catch (Dali::DaliException e) {
62370       {
62371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62372       };
62373     } catch (...) {
62374       {
62375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62376       };
62377     }
62378   }
62379
62380   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62381
62382   //argout typemap for const std::string&
62383
62384   return jresult;
62385 }
62386
62387
62388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62389   void * jresult ;
62390   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62391   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62392
62393   arg1 = (Dali::Toolkit::Builder *)jarg1;
62394   {
62395     try {
62396       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62397     } catch (std::out_of_range& e) {
62398       {
62399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62400       };
62401     } catch (std::exception& e) {
62402       {
62403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62404       };
62405     } catch (Dali::DaliException e) {
62406       {
62407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62408       };
62409     } catch (...) {
62410       {
62411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62412       };
62413     }
62414   }
62415
62416   jresult = (void *)result;
62417   return jresult;
62418 }
62419
62420
62421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62422   void * jresult ;
62423   Dali::Toolkit::TransitionData *result = 0 ;
62424
62425   {
62426     try {
62427       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62428     } catch (std::out_of_range& e) {
62429       {
62430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62431       };
62432     } catch (std::exception& e) {
62433       {
62434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62435       };
62436     } catch (Dali::DaliException e) {
62437       {
62438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62439       };
62440     } catch (...) {
62441       {
62442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62443       };
62444     }
62445   }
62446
62447   jresult = (void *)result;
62448   return jresult;
62449 }
62450
62451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62452   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62453
62454   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62455   {
62456     try {
62457       delete arg1;
62458     } catch (std::out_of_range& e) {
62459       {
62460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62461       };
62462     } catch (std::exception& e) {
62463       {
62464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62465       };
62466     } catch (Dali::DaliException e) {
62467       {
62468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62469       };
62470     } catch (...) {
62471       {
62472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62473       };
62474     }
62475   }
62476
62477 }
62478
62479
62480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62481   void * jresult ;
62482   Dali::Property::Map *arg1 = 0 ;
62483   Dali::Toolkit::TransitionData result;
62484
62485   arg1 = (Dali::Property::Map *)jarg1;
62486   if (!arg1) {
62487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62488     return 0;
62489   }
62490   {
62491     try {
62492       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62493     } catch (std::out_of_range& e) {
62494       {
62495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62496       };
62497     } catch (std::exception& e) {
62498       {
62499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62500       };
62501     } catch (Dali::DaliException e) {
62502       {
62503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62504       };
62505     } catch (...) {
62506       {
62507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62508       };
62509     }
62510   }
62511
62512   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62513   return jresult;
62514 }
62515
62516
62517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62518   void * jresult ;
62519   Dali::Property::Array *arg1 = 0 ;
62520   Dali::Toolkit::TransitionData result;
62521
62522   arg1 = (Dali::Property::Array *)jarg1;
62523   if (!arg1) {
62524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62525     return 0;
62526   }
62527   {
62528     try {
62529       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62530     } catch (std::out_of_range& e) {
62531       {
62532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62533       };
62534     } catch (std::exception& e) {
62535       {
62536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62537       };
62538     } catch (Dali::DaliException e) {
62539       {
62540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62541       };
62542     } catch (...) {
62543       {
62544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62545       };
62546     }
62547   }
62548
62549   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62550   return jresult;
62551 }
62552
62553
62554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62555   void * jresult ;
62556   Dali::BaseHandle arg1 ;
62557   Dali::BaseHandle *argp1 ;
62558   Dali::Toolkit::TransitionData result;
62559
62560   argp1 = (Dali::BaseHandle *)jarg1;
62561   if (!argp1) {
62562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62563     return 0;
62564   }
62565   arg1 = *argp1;
62566   {
62567     try {
62568       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62569     } catch (std::out_of_range& e) {
62570       {
62571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62572       };
62573     } catch (std::exception& e) {
62574       {
62575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62576       };
62577     } catch (Dali::DaliException e) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62580       };
62581     } catch (...) {
62582       {
62583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62584       };
62585     }
62586   }
62587
62588   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62589   return jresult;
62590 }
62591
62592
62593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62594   void * jresult ;
62595   Dali::Toolkit::TransitionData *arg1 = 0 ;
62596   Dali::Toolkit::TransitionData *result = 0 ;
62597
62598   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62599   if (!arg1) {
62600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62601     return 0;
62602   }
62603   {
62604     try {
62605       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62606     } catch (std::out_of_range& e) {
62607       {
62608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62609       };
62610     } catch (std::exception& e) {
62611       {
62612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (Dali::DaliException e) {
62615       {
62616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62617       };
62618     } catch (...) {
62619       {
62620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62621       };
62622     }
62623   }
62624
62625   jresult = (void *)result;
62626   return jresult;
62627 }
62628
62629
62630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62631   void * jresult ;
62632   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62633   Dali::Toolkit::TransitionData *arg2 = 0 ;
62634   Dali::Toolkit::TransitionData *result = 0 ;
62635
62636   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62637   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62638   if (!arg2) {
62639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62640     return 0;
62641   }
62642   {
62643     try {
62644       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62645     } catch (std::out_of_range& e) {
62646       {
62647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62648       };
62649     } catch (std::exception& e) {
62650       {
62651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62652       };
62653     } catch (Dali::DaliException e) {
62654       {
62655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62656       };
62657     } catch (...) {
62658       {
62659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62660       };
62661     }
62662   }
62663
62664   jresult = (void *)result;
62665   return jresult;
62666 }
62667
62668
62669 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62670   unsigned long jresult ;
62671   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62672   size_t result;
62673
62674   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62675   {
62676     try {
62677       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62678     } catch (std::out_of_range& e) {
62679       {
62680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62681       };
62682     } catch (std::exception& e) {
62683       {
62684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62685       };
62686     } catch (Dali::DaliException e) {
62687       {
62688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62689       };
62690     } catch (...) {
62691       {
62692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62693       };
62694     }
62695   }
62696
62697   jresult = (unsigned long)result;
62698   return jresult;
62699 }
62700
62701
62702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62703   void * jresult ;
62704   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62705   size_t arg2 ;
62706   Dali::Property::Map result;
62707
62708   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62709   arg2 = (size_t)jarg2;
62710   {
62711     try {
62712       result = (arg1)->GetAnimatorAt(arg2);
62713     } catch (std::out_of_range& e) {
62714       {
62715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62716       };
62717     } catch (std::exception& e) {
62718       {
62719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62720       };
62721     } catch (Dali::DaliException e) {
62722       {
62723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62724       };
62725     } catch (...) {
62726       {
62727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62728       };
62729     }
62730   }
62731
62732   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62733   return jresult;
62734 }
62735
62736
62737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62738   int jresult ;
62739   int result;
62740
62741   {
62742     try {
62743       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62744     } catch (std::out_of_range& e) {
62745       {
62746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62747       };
62748     } catch (std::exception& e) {
62749       {
62750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62751       };
62752     } catch (Dali::DaliException e) {
62753       {
62754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62755       };
62756     } catch (...) {
62757       {
62758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62759       };
62760     }
62761   }
62762
62763   jresult = (int)result;
62764   return jresult;
62765 }
62766
62767
62768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62769   int jresult ;
62770   int result;
62771
62772   {
62773     try {
62774       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62775     } catch (std::out_of_range& e) {
62776       {
62777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62778       };
62779     } catch (std::exception& e) {
62780       {
62781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62782       };
62783     } catch (Dali::DaliException e) {
62784       {
62785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62786       };
62787     } catch (...) {
62788       {
62789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62790       };
62791     }
62792   }
62793
62794   jresult = (int)result;
62795   return jresult;
62796 }
62797
62798
62799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62800   int jresult ;
62801   int result;
62802
62803   {
62804     try {
62805       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62806     } catch (std::out_of_range& e) {
62807       {
62808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62809       };
62810     } catch (std::exception& e) {
62811       {
62812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62813       };
62814     } catch (Dali::DaliException e) {
62815       {
62816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62817       };
62818     } catch (...) {
62819       {
62820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62821       };
62822     }
62823   }
62824
62825   jresult = (int)result;
62826   return jresult;
62827 }
62828
62829
62830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62831   int jresult ;
62832   int result;
62833
62834   {
62835     try {
62836       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62837     } catch (std::out_of_range& e) {
62838       {
62839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62840       };
62841     } catch (std::exception& e) {
62842       {
62843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62844       };
62845     } catch (Dali::DaliException e) {
62846       {
62847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62848       };
62849     } catch (...) {
62850       {
62851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62852       };
62853     }
62854   }
62855
62856   jresult = (int)result;
62857   return jresult;
62858 }
62859
62860
62861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62862   int jresult ;
62863   int result;
62864
62865   {
62866     try {
62867       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62868     } catch (std::out_of_range& e) {
62869       {
62870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62871       };
62872     } catch (std::exception& e) {
62873       {
62874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62875       };
62876     } catch (Dali::DaliException e) {
62877       {
62878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62879       };
62880     } catch (...) {
62881       {
62882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62883       };
62884     }
62885   }
62886
62887   jresult = (int)result;
62888   return jresult;
62889 }
62890
62891
62892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62893   int jresult ;
62894   int result;
62895
62896   {
62897     try {
62898       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62899     } catch (std::out_of_range& e) {
62900       {
62901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62902       };
62903     } catch (std::exception& e) {
62904       {
62905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62906       };
62907     } catch (Dali::DaliException e) {
62908       {
62909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62910       };
62911     } catch (...) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62914       };
62915     }
62916   }
62917
62918   jresult = (int)result;
62919   return jresult;
62920 }
62921
62922
62923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62924   int jresult ;
62925   int result;
62926
62927   {
62928     try {
62929       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62930     } catch (std::out_of_range& e) {
62931       {
62932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62933       };
62934     } catch (std::exception& e) {
62935       {
62936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62937       };
62938     } catch (Dali::DaliException e) {
62939       {
62940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62941       };
62942     } catch (...) {
62943       {
62944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62945       };
62946     }
62947   }
62948
62949   jresult = (int)result;
62950   return jresult;
62951 }
62952
62953
62954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62955   int jresult ;
62956   int result;
62957
62958   {
62959     try {
62960       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62961     } catch (std::out_of_range& e) {
62962       {
62963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62964       };
62965     } catch (std::exception& e) {
62966       {
62967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62968       };
62969     } catch (Dali::DaliException e) {
62970       {
62971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62972       };
62973     } catch (...) {
62974       {
62975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62976       };
62977     }
62978   }
62979
62980   jresult = (int)result;
62981   return jresult;
62982 }
62983
62984
62985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62986   int jresult ;
62987   int result;
62988
62989   {
62990     try {
62991       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62992     } catch (std::out_of_range& e) {
62993       {
62994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62995       };
62996     } catch (std::exception& e) {
62997       {
62998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62999       };
63000     } catch (Dali::DaliException e) {
63001       {
63002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63003       };
63004     } catch (...) {
63005       {
63006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63007       };
63008     }
63009   }
63010
63011   jresult = (int)result;
63012   return jresult;
63013 }
63014
63015
63016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63017   int jresult ;
63018   int result;
63019
63020   {
63021     try {
63022       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63023     } catch (std::out_of_range& e) {
63024       {
63025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63026       };
63027     } catch (std::exception& e) {
63028       {
63029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63030       };
63031     } catch (Dali::DaliException e) {
63032       {
63033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63034       };
63035     } catch (...) {
63036       {
63037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63038       };
63039     }
63040   }
63041
63042   jresult = (int)result;
63043   return jresult;
63044 }
63045
63046
63047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63048   int jresult ;
63049   int result;
63050
63051   {
63052     try {
63053       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63054     } catch (std::out_of_range& e) {
63055       {
63056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63057       };
63058     } catch (std::exception& e) {
63059       {
63060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63061       };
63062     } catch (Dali::DaliException e) {
63063       {
63064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63065       };
63066     } catch (...) {
63067       {
63068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63069       };
63070     }
63071   }
63072
63073   jresult = (int)result;
63074   return jresult;
63075 }
63076
63077
63078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63079   int jresult ;
63080   int result;
63081
63082   {
63083     try {
63084       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63085     } catch (std::out_of_range& e) {
63086       {
63087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63088       };
63089     } catch (std::exception& e) {
63090       {
63091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63092       };
63093     } catch (Dali::DaliException e) {
63094       {
63095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63096       };
63097     } catch (...) {
63098       {
63099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63100       };
63101     }
63102   }
63103
63104   jresult = (int)result;
63105   return jresult;
63106 }
63107
63108
63109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63110   int jresult ;
63111   int result;
63112
63113   {
63114     try {
63115       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63116     } catch (std::out_of_range& e) {
63117       {
63118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63119       };
63120     } catch (std::exception& e) {
63121       {
63122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63123       };
63124     } catch (Dali::DaliException e) {
63125       {
63126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63127       };
63128     } catch (...) {
63129       {
63130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63131       };
63132     }
63133   }
63134
63135   jresult = (int)result;
63136   return jresult;
63137 }
63138
63139
63140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63141   int jresult ;
63142   int result;
63143
63144   {
63145     try {
63146       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63147     } catch (std::out_of_range& e) {
63148       {
63149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63150       };
63151     } catch (std::exception& e) {
63152       {
63153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63154       };
63155     } catch (Dali::DaliException e) {
63156       {
63157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63158       };
63159     } catch (...) {
63160       {
63161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63162       };
63163     }
63164   }
63165
63166   jresult = (int)result;
63167   return jresult;
63168 }
63169
63170
63171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63172   void * jresult ;
63173   Dali::Toolkit::Control result;
63174
63175   {
63176     try {
63177       result = Dali::Toolkit::Internal::Control::New();
63178     } catch (std::out_of_range& e) {
63179       {
63180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63181       };
63182     } catch (std::exception& e) {
63183       {
63184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63185       };
63186     } catch (Dali::DaliException e) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63189       };
63190     } catch (...) {
63191       {
63192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63193       };
63194     }
63195   }
63196
63197   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63198   return jresult;
63199 }
63200
63201
63202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63204   std::string *arg2 = 0 ;
63205
63206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63207   if (!jarg2) {
63208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63209     return ;
63210   }
63211   std::string arg2_str(jarg2);
63212   arg2 = &arg2_str;
63213   {
63214     try {
63215       (arg1)->SetStyleName((std::string const &)*arg2);
63216     } catch (std::out_of_range& e) {
63217       {
63218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63219       };
63220     } catch (std::exception& e) {
63221       {
63222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63223       };
63224     } catch (Dali::DaliException e) {
63225       {
63226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63227       };
63228     } catch (...) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63231       };
63232     }
63233   }
63234
63235
63236   //argout typemap for const std::string&
63237
63238 }
63239
63240
63241 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63242   char * jresult ;
63243   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63244   std::string *result = 0 ;
63245
63246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63247   {
63248     try {
63249       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63250     } catch (std::out_of_range& e) {
63251       {
63252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63253       };
63254     } catch (std::exception& e) {
63255       {
63256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63257       };
63258     } catch (Dali::DaliException e) {
63259       {
63260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63261       };
63262     } catch (...) {
63263       {
63264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63265       };
63266     }
63267   }
63268
63269   jresult = SWIG_csharp_string_callback(result->c_str());
63270   return jresult;
63271 }
63272
63273
63274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63276   Dali::Vector4 *arg2 = 0 ;
63277
63278   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63279   arg2 = (Dali::Vector4 *)jarg2;
63280   if (!arg2) {
63281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63282     return ;
63283   }
63284   {
63285     try {
63286       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63287     } catch (std::out_of_range& e) {
63288       {
63289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63290       };
63291     } catch (std::exception& e) {
63292       {
63293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63294       };
63295     } catch (Dali::DaliException e) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63298       };
63299     } catch (...) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63302       };
63303     }
63304   }
63305
63306 }
63307
63308
63309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63310   void * jresult ;
63311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63312   Dali::Vector4 result;
63313
63314   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63315   {
63316     try {
63317       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63318     } catch (std::out_of_range& e) {
63319       {
63320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63321       };
63322     } catch (std::exception& e) {
63323       {
63324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63325       };
63326     } catch (Dali::DaliException e) {
63327       {
63328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63329       };
63330     } catch (...) {
63331       {
63332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63333       };
63334     }
63335   }
63336
63337   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63338   return jresult;
63339 }
63340
63341
63342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63344   Dali::Image arg2 ;
63345   Dali::Image *argp2 ;
63346
63347   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63348   argp2 = (Dali::Image *)jarg2;
63349   if (!argp2) {
63350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63351     return ;
63352   }
63353   arg2 = *argp2;
63354   {
63355     try {
63356       (arg1)->SetBackgroundImage(arg2);
63357     } catch (std::out_of_range& e) {
63358       {
63359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63360       };
63361     } catch (std::exception& e) {
63362       {
63363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63364       };
63365     } catch (Dali::DaliException e) {
63366       {
63367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63368       };
63369     } catch (...) {
63370       {
63371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63372       };
63373     }
63374   }
63375
63376 }
63377
63378
63379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63381   Dali::Property::Map *arg2 = 0 ;
63382
63383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63384   arg2 = (Dali::Property::Map *)jarg2;
63385   if (!arg2) {
63386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63387     return ;
63388   }
63389   {
63390     try {
63391       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63392     } catch (std::out_of_range& e) {
63393       {
63394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63395       };
63396     } catch (std::exception& e) {
63397       {
63398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63399       };
63400     } catch (Dali::DaliException e) {
63401       {
63402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63403       };
63404     } catch (...) {
63405       {
63406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63407       };
63408     }
63409   }
63410
63411 }
63412
63413
63414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63416
63417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63418   {
63419     try {
63420       (arg1)->ClearBackground();
63421     } catch (std::out_of_range& e) {
63422       {
63423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63424       };
63425     } catch (std::exception& e) {
63426       {
63427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63428       };
63429     } catch (Dali::DaliException e) {
63430       {
63431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63432       };
63433     } catch (...) {
63434       {
63435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63436       };
63437     }
63438   }
63439
63440 }
63441
63442
63443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63445   Dali::Gesture::Type arg2 ;
63446
63447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63448   arg2 = (Dali::Gesture::Type)jarg2;
63449   {
63450     try {
63451       (arg1)->EnableGestureDetection(arg2);
63452     } catch (std::out_of_range& e) {
63453       {
63454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63455       };
63456     } catch (std::exception& e) {
63457       {
63458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63459       };
63460     } catch (Dali::DaliException e) {
63461       {
63462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63463       };
63464     } catch (...) {
63465       {
63466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63467       };
63468     }
63469   }
63470
63471 }
63472
63473
63474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63476   Dali::Gesture::Type arg2 ;
63477
63478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63479   arg2 = (Dali::Gesture::Type)jarg2;
63480   {
63481     try {
63482       (arg1)->DisableGestureDetection(arg2);
63483     } catch (std::out_of_range& e) {
63484       {
63485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63486       };
63487     } catch (std::exception& e) {
63488       {
63489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63490       };
63491     } catch (Dali::DaliException e) {
63492       {
63493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63494       };
63495     } catch (...) {
63496       {
63497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63498       };
63499     }
63500   }
63501
63502 }
63503
63504
63505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63506   void * jresult ;
63507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63508   Dali::PinchGestureDetector result;
63509
63510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63511   {
63512     try {
63513       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63514     } catch (std::out_of_range& e) {
63515       {
63516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63517       };
63518     } catch (std::exception& e) {
63519       {
63520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63521       };
63522     } catch (Dali::DaliException e) {
63523       {
63524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63525       };
63526     } catch (...) {
63527       {
63528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63529       };
63530     }
63531   }
63532
63533   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63534   return jresult;
63535 }
63536
63537
63538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63539   void * jresult ;
63540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63541   Dali::PanGestureDetector result;
63542
63543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63544   {
63545     try {
63546       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63547     } catch (std::out_of_range& e) {
63548       {
63549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63550       };
63551     } catch (std::exception& e) {
63552       {
63553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63554       };
63555     } catch (Dali::DaliException e) {
63556       {
63557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63558       };
63559     } catch (...) {
63560       {
63561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63562       };
63563     }
63564   }
63565
63566   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63567   return jresult;
63568 }
63569
63570
63571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63572   void * jresult ;
63573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63574   Dali::TapGestureDetector result;
63575
63576   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63577   {
63578     try {
63579       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63580     } catch (std::out_of_range& e) {
63581       {
63582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63583       };
63584     } catch (std::exception& e) {
63585       {
63586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63587       };
63588     } catch (Dali::DaliException e) {
63589       {
63590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63591       };
63592     } catch (...) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63595       };
63596     }
63597   }
63598
63599   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63600   return jresult;
63601 }
63602
63603
63604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63605   void * jresult ;
63606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63607   Dali::LongPressGestureDetector result;
63608
63609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63610   {
63611     try {
63612       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63613     } catch (std::out_of_range& e) {
63614       {
63615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63616       };
63617     } catch (std::exception& e) {
63618       {
63619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63620       };
63621     } catch (Dali::DaliException e) {
63622       {
63623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63624       };
63625     } catch (...) {
63626       {
63627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63628       };
63629     }
63630   }
63631
63632   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63633   return jresult;
63634 }
63635
63636
63637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63639   bool arg2 ;
63640
63641   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63642   arg2 = jarg2 ? true : false;
63643   {
63644     try {
63645       (arg1)->SetKeyboardNavigationSupport(arg2);
63646     } catch (std::out_of_range& e) {
63647       {
63648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63649       };
63650     } catch (std::exception& e) {
63651       {
63652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63653       };
63654     } catch (Dali::DaliException e) {
63655       {
63656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63657       };
63658     } catch (...) {
63659       {
63660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63661       };
63662     }
63663   }
63664
63665 }
63666
63667
63668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63669   unsigned int jresult ;
63670   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63671   bool result;
63672
63673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63674   {
63675     try {
63676       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63677     } catch (std::out_of_range& e) {
63678       {
63679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63680       };
63681     } catch (std::exception& e) {
63682       {
63683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63684       };
63685     } catch (Dali::DaliException e) {
63686       {
63687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63688       };
63689     } catch (...) {
63690       {
63691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63692       };
63693     }
63694   }
63695
63696   jresult = result;
63697   return jresult;
63698 }
63699
63700
63701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63703
63704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63705   {
63706     try {
63707       (arg1)->SetKeyInputFocus();
63708     } catch (std::out_of_range& e) {
63709       {
63710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63711       };
63712     } catch (std::exception& e) {
63713       {
63714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63715       };
63716     } catch (Dali::DaliException e) {
63717       {
63718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63719       };
63720     } catch (...) {
63721       {
63722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63723       };
63724     }
63725   }
63726
63727 }
63728
63729
63730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63731   unsigned int jresult ;
63732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63733   bool result;
63734
63735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63736   {
63737     try {
63738       result = (bool)(arg1)->HasKeyInputFocus();
63739     } catch (std::out_of_range& e) {
63740       {
63741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63742       };
63743     } catch (std::exception& e) {
63744       {
63745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63746       };
63747     } catch (Dali::DaliException e) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63750       };
63751     } catch (...) {
63752       {
63753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63754       };
63755     }
63756   }
63757
63758   jresult = result;
63759   return jresult;
63760 }
63761
63762
63763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63764   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63765
63766   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63767   {
63768     try {
63769       (arg1)->ClearKeyInputFocus();
63770     } catch (std::out_of_range& e) {
63771       {
63772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63773       };
63774     } catch (std::exception& e) {
63775       {
63776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63777       };
63778     } catch (Dali::DaliException e) {
63779       {
63780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63781       };
63782     } catch (...) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63785       };
63786     }
63787   }
63788
63789 }
63790
63791
63792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63793   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63794   bool arg2 ;
63795
63796   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63797   arg2 = jarg2 ? true : false;
63798   {
63799     try {
63800       (arg1)->SetAsKeyboardFocusGroup(arg2);
63801     } catch (std::out_of_range& e) {
63802       {
63803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63804       };
63805     } catch (std::exception& e) {
63806       {
63807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63808       };
63809     } catch (Dali::DaliException e) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63812       };
63813     } catch (...) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63816       };
63817     }
63818   }
63819
63820 }
63821
63822
63823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63824   unsigned int jresult ;
63825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63826   bool result;
63827
63828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63829   {
63830     try {
63831       result = (bool)(arg1)->IsKeyboardFocusGroup();
63832     } catch (std::out_of_range& e) {
63833       {
63834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63835       };
63836     } catch (std::exception& e) {
63837       {
63838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63839       };
63840     } catch (Dali::DaliException e) {
63841       {
63842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63843       };
63844     } catch (...) {
63845       {
63846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63847       };
63848     }
63849   }
63850
63851   jresult = result;
63852   return jresult;
63853 }
63854
63855
63856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63857   void * jresult ;
63858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63859   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63860
63861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63862   {
63863     try {
63864       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63865     } catch (std::out_of_range& e) {
63866       {
63867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63868       };
63869     } catch (std::exception& e) {
63870       {
63871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63872       };
63873     } catch (Dali::DaliException e) {
63874       {
63875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63876       };
63877     } catch (...) {
63878       {
63879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63880       };
63881     }
63882   }
63883
63884   jresult = (void *)result;
63885   return jresult;
63886 }
63887
63888
63889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63890   void * jresult ;
63891   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63892   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63893
63894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63895   {
63896     try {
63897       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63898     } catch (std::out_of_range& e) {
63899       {
63900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63901       };
63902     } catch (std::exception& e) {
63903       {
63904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63905       };
63906     } catch (Dali::DaliException e) {
63907       {
63908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63909       };
63910     } catch (...) {
63911       {
63912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63913       };
63914     }
63915   }
63916
63917   jresult = (void *)result;
63918   return jresult;
63919 }
63920
63921
63922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63923   void * jresult ;
63924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63925   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63926
63927   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63928   {
63929     try {
63930       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63931     } catch (std::out_of_range& e) {
63932       {
63933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63934       };
63935     } catch (std::exception& e) {
63936       {
63937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63938       };
63939     } catch (Dali::DaliException e) {
63940       {
63941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63942       };
63943     } catch (...) {
63944       {
63945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63946       };
63947     }
63948   }
63949
63950   jresult = (void *)result;
63951   return jresult;
63952 }
63953
63954
63955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63957   int arg2 ;
63958   SwigDirector_ViewImpl *darg = 0;
63959
63960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63961   arg2 = (int)jarg2;
63962   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63963   if(!darg) {
63964     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63965     return;
63966   }
63967   {
63968     try {
63969       if(darg) {
63970         (darg)->OnStageConnection(arg2);
63971       }
63972     } catch (std::out_of_range& e) {
63973       {
63974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63975       };
63976     } catch (std::exception& e) {
63977       {
63978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63979       };
63980     } catch (Dali::DaliException e) {
63981       {
63982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63983       };
63984     } catch (...) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63987       };
63988     }
63989   }
63990
63991 }
63992
63993
63994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63996   int arg2 ;
63997   SwigDirector_ViewImpl *darg = 0;
63998
63999   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64000   arg2 = (int)jarg2;
64001   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64002   if(!darg) {
64003     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64004     return;
64005   }
64006   {
64007     try {
64008       if(darg) {
64009         (darg)->OnStageConnectionSwigPublic(arg2);
64010       }
64011     } catch (std::out_of_range& e) {
64012       {
64013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64014       };
64015     } catch (std::exception& e) {
64016       {
64017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64018       };
64019     } catch (Dali::DaliException e) {
64020       {
64021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64022       };
64023     } catch (...) {
64024       {
64025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64026       };
64027     }
64028   }
64029
64030 }
64031
64032
64033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64034   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64035   SwigDirector_ViewImpl *darg = 0;
64036
64037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64038   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64039   if(!darg) {
64040     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64041     return;
64042   }
64043   {
64044     try {
64045       if(darg) {
64046         (darg)->OnStageDisconnection();
64047       }
64048     } catch (std::out_of_range& e) {
64049       {
64050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64051       };
64052     } catch (std::exception& e) {
64053       {
64054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64055       };
64056     } catch (Dali::DaliException e) {
64057       {
64058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64059       };
64060     } catch (...) {
64061       {
64062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64063       };
64064     }
64065   }
64066
64067 }
64068
64069
64070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64072   SwigDirector_ViewImpl *darg = 0;
64073
64074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64075   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64076   if(!darg) {
64077     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64078     return;
64079   }
64080   {
64081     try {
64082       if(darg) {
64083         (darg)->OnStageDisconnectionSwigPublic();
64084       }
64085     } catch (std::out_of_range& e) {
64086       {
64087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64088       };
64089     } catch (std::exception& e) {
64090       {
64091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64092       };
64093     } catch (Dali::DaliException e) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64096       };
64097     } catch (...) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64100       };
64101     }
64102   }
64103
64104 }
64105
64106
64107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64109   Dali::Actor *arg2 = 0 ;
64110   SwigDirector_ViewImpl *darg = 0;
64111
64112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64113   arg2 = (Dali::Actor *)jarg2;
64114   if (!arg2) {
64115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64116     return ;
64117   }
64118   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64119   if(!darg) {
64120     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64121     return;
64122   }
64123   {
64124     try {
64125       if(darg) {
64126         (darg)->OnChildAdd(*arg2);
64127       }
64128     } catch (std::out_of_range& e) {
64129       {
64130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64131       };
64132     } catch (std::exception& e) {
64133       {
64134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64135       };
64136     } catch (Dali::DaliException e) {
64137       {
64138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64139       };
64140     } catch (...) {
64141       {
64142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64143       };
64144     }
64145   }
64146
64147 }
64148
64149
64150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64152   Dali::Actor *arg2 = 0 ;
64153   SwigDirector_ViewImpl *darg = 0;
64154
64155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64156   arg2 = (Dali::Actor *)jarg2;
64157   if (!arg2) {
64158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64159     return ;
64160   }
64161   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64162   if(!darg) {
64163     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64164     return;
64165   }
64166   {
64167     try {
64168       if(darg) {
64169           (darg)->OnChildAddSwigPublic(*arg2);
64170       }
64171     } catch (std::out_of_range& e) {
64172       {
64173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64174       };
64175     } catch (std::exception& e) {
64176       {
64177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64178       };
64179     } catch (Dali::DaliException e) {
64180       {
64181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64182       };
64183     } catch (...) {
64184       {
64185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64186       };
64187     }
64188   }
64189
64190 }
64191
64192
64193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64195   Dali::Actor *arg2 = 0 ;
64196   SwigDirector_ViewImpl *darg = 0;
64197
64198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64199   arg2 = (Dali::Actor *)jarg2;
64200   if (!arg2) {
64201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64202     return ;
64203   }
64204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64205   if(!darg) {
64206     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64207     return;
64208   }
64209   {
64210     try {
64211       if(darg) {
64212         (darg)->OnChildRemove(*arg2);
64213       }
64214     } catch (std::out_of_range& e) {
64215       {
64216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64217       };
64218     } catch (std::exception& e) {
64219       {
64220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64221       };
64222     } catch (Dali::DaliException e) {
64223       {
64224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64225       };
64226     } catch (...) {
64227       {
64228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64229       };
64230     }
64231   }
64232
64233 }
64234
64235
64236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64237   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64238   Dali::Actor *arg2 = 0 ;
64239   SwigDirector_ViewImpl *darg = 0;
64240
64241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64242   arg2 = (Dali::Actor *)jarg2;
64243   if (!arg2) {
64244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64245     return ;
64246   }
64247   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64248   if(!darg) {
64249     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64250     return;
64251   }
64252   {
64253     try {
64254       if(darg) {
64255         (darg)->OnChildRemoveSwigPublic(*arg2);
64256       }
64257     } catch (std::out_of_range& e) {
64258       {
64259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64260       };
64261     } catch (std::exception& e) {
64262       {
64263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64264       };
64265     } catch (Dali::DaliException e) {
64266       {
64267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64268       };
64269     } catch (...) {
64270       {
64271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64272       };
64273     }
64274   }
64275
64276 }
64277
64278
64279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64281   Dali::Property::Index arg2 ;
64282   Dali::Property::Value arg3 ;
64283   Dali::Property::Value *argp3 ;
64284   SwigDirector_ViewImpl *darg = 0;
64285
64286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64287   arg2 = (Dali::Property::Index)jarg2;
64288   argp3 = (Dali::Property::Value *)jarg3;
64289   if (!argp3) {
64290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64291     return ;
64292   }
64293   arg3 = *argp3;
64294   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64295   if (!darg) {
64296     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64297     return;
64298   }
64299   {
64300     try {
64301       (darg)->OnPropertySet(arg2,arg3);
64302     } catch (std::out_of_range& e) {
64303       {
64304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64305       };
64306     } catch (std::exception& e) {
64307       {
64308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64309       };
64310     } catch (Dali::DaliException e) {
64311       {
64312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64313       };
64314     } catch (...) {
64315       {
64316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64317       };
64318     }
64319   }
64320
64321 }
64322
64323
64324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64326   Dali::Property::Index arg2 ;
64327   Dali::Property::Value arg3 ;
64328   Dali::Property::Value *argp3 ;
64329   SwigDirector_ViewImpl *darg = 0;
64330
64331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64332   arg2 = (Dali::Property::Index)jarg2;
64333   argp3 = (Dali::Property::Value *)jarg3;
64334   if (!argp3) {
64335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64336     return ;
64337   }
64338   arg3 = *argp3;
64339   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64340   if (!darg) {
64341     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64342     return;
64343   }
64344   {
64345     try {
64346       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64347     } catch (std::out_of_range& e) {
64348       {
64349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64350       };
64351     } catch (std::exception& e) {
64352       {
64353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64354       };
64355     } catch (Dali::DaliException e) {
64356       {
64357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64358       };
64359     } catch (...) {
64360       {
64361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64362       };
64363     }
64364   }
64365
64366 }
64367
64368
64369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64371   Dali::Vector3 *arg2 = 0 ;
64372   SwigDirector_ViewImpl *darg = 0;
64373
64374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64375   arg2 = (Dali::Vector3 *)jarg2;
64376   if (!arg2) {
64377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64378     return ;
64379   }
64380   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64381   if (!darg) {
64382     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64383     return;
64384   }
64385   {
64386     try {
64387       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64388     } catch (std::out_of_range& e) {
64389       {
64390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64391       };
64392     } catch (std::exception& e) {
64393       {
64394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64395       };
64396     } catch (Dali::DaliException e) {
64397       {
64398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64399       };
64400     } catch (...) {
64401       {
64402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64403       };
64404     }
64405   }
64406
64407 }
64408
64409
64410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64412   Dali::Vector3 *arg2 = 0 ;
64413   SwigDirector_ViewImpl *darg = 0;
64414
64415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64416   arg2 = (Dali::Vector3 *)jarg2;
64417   if (!arg2) {
64418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64419     return ;
64420   }
64421   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64422   if (!darg) {
64423     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64424     return;
64425   }
64426   {
64427     try {
64428       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64429     } catch (std::out_of_range& e) {
64430       {
64431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64432       };
64433     } catch (std::exception& e) {
64434       {
64435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64436       };
64437     } catch (Dali::DaliException e) {
64438       {
64439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64440       };
64441     } catch (...) {
64442       {
64443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64444       };
64445     }
64446   }
64447
64448 }
64449
64450
64451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64452   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64453   Dali::Animation *arg2 = 0 ;
64454   Dali::Vector3 *arg3 = 0 ;
64455   SwigDirector_ViewImpl *darg = 0;
64456
64457   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64458   arg2 = (Dali::Animation *)jarg2;
64459   if (!arg2) {
64460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64461     return ;
64462   }
64463   arg3 = (Dali::Vector3 *)jarg3;
64464   if (!arg3) {
64465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64466     return ;
64467   }
64468   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64469   if (!darg) {
64470     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64471     return;
64472   }
64473   {
64474     try {
64475       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64476     } catch (std::out_of_range& e) {
64477       {
64478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64479       };
64480     } catch (std::exception& e) {
64481       {
64482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64483       };
64484     } catch (Dali::DaliException e) {
64485       {
64486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64487       };
64488     } catch (...) {
64489       {
64490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64491       };
64492     }
64493   }
64494
64495 }
64496
64497
64498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64500   Dali::Animation *arg2 = 0 ;
64501   Dali::Vector3 *arg3 = 0 ;
64502   SwigDirector_ViewImpl *darg = 0;
64503
64504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64505   arg2 = (Dali::Animation *)jarg2;
64506   if (!arg2) {
64507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64508     return ;
64509   }
64510   arg3 = (Dali::Vector3 *)jarg3;
64511   if (!arg3) {
64512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64513     return ;
64514   }
64515   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64516   if (!darg) {
64517     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64518     return;
64519   }
64520   {
64521     try {
64522       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64523     } catch (std::out_of_range& e) {
64524       {
64525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64526       };
64527     } catch (std::exception& e) {
64528       {
64529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64530       };
64531     } catch (Dali::DaliException e) {
64532       {
64533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64534       };
64535     } catch (...) {
64536       {
64537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64538       };
64539     }
64540   }
64541
64542 }
64543
64544
64545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64546   unsigned int jresult ;
64547   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64548   Dali::TouchEvent *arg2 = 0 ;
64549   SwigDirector_ViewImpl *darg = 0;
64550   bool result;
64551
64552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64553   arg2 = (Dali::TouchEvent *)jarg2;
64554   if (!arg2) {
64555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64556     return 0;
64557   }
64558   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64559   if (!darg) {
64560     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64561     return 0;
64562   }
64563   {
64564     try {
64565       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64566     } catch (std::out_of_range& e) {
64567       {
64568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64569       };
64570     } catch (std::exception& e) {
64571       {
64572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64573       };
64574     } catch (Dali::DaliException e) {
64575       {
64576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64577       };
64578     } catch (...) {
64579       {
64580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64581       };
64582     }
64583   }
64584
64585   jresult = result;
64586   return jresult;
64587 }
64588
64589
64590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64591   unsigned int jresult ;
64592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64593   Dali::TouchEvent *arg2 = 0 ;
64594   SwigDirector_ViewImpl *darg = 0;
64595   bool result;
64596
64597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64598   arg2 = (Dali::TouchEvent *)jarg2;
64599   if (!arg2) {
64600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64601     return 0;
64602   }
64603   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64604   if (!darg) {
64605     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64606     return 0;
64607   }
64608   {
64609     try {
64610       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64611     } catch (std::out_of_range& e) {
64612       {
64613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64614       };
64615     } catch (std::exception& e) {
64616       {
64617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64618       };
64619     } catch (Dali::DaliException e) {
64620       {
64621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64622       };
64623     } catch (...) {
64624       {
64625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64626       };
64627     }
64628   }
64629
64630   jresult = result;
64631   return jresult;
64632 }
64633
64634
64635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64636   unsigned int jresult ;
64637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64638   Dali::HoverEvent *arg2 = 0 ;
64639   SwigDirector_ViewImpl *darg = 0;
64640   bool result;
64641
64642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64643   arg2 = (Dali::HoverEvent *)jarg2;
64644   if (!arg2) {
64645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64646     return 0;
64647   }
64648   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64649   if (!darg) {
64650     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64651     return 0;
64652   }
64653   {
64654     try {
64655       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64656     } catch (std::out_of_range& e) {
64657       {
64658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64659       };
64660     } catch (std::exception& e) {
64661       {
64662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64663       };
64664     } catch (Dali::DaliException e) {
64665       {
64666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64667       };
64668     } catch (...) {
64669       {
64670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64671       };
64672     }
64673   }
64674
64675   jresult = result;
64676   return jresult;
64677 }
64678
64679
64680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64681   unsigned int jresult ;
64682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64683   Dali::HoverEvent *arg2 = 0 ;
64684   SwigDirector_ViewImpl *darg = 0;
64685   bool result;
64686
64687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64688   arg2 = (Dali::HoverEvent *)jarg2;
64689   if (!arg2) {
64690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64691     return 0;
64692   }
64693   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64694   if (!darg) {
64695     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64696     return 0;
64697   }
64698   {
64699     try {
64700       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64701     } catch (std::out_of_range& e) {
64702       {
64703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64704       };
64705     } catch (std::exception& e) {
64706       {
64707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64708       };
64709     } catch (Dali::DaliException e) {
64710       {
64711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64712       };
64713     } catch (...) {
64714       {
64715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64716       };
64717     }
64718   }
64719
64720   jresult = result;
64721   return jresult;
64722 }
64723
64724
64725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64726   unsigned int jresult ;
64727   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64728   Dali::KeyEvent *arg2 = 0 ;
64729   SwigDirector_ViewImpl *darg = 0;
64730   bool result;
64731
64732   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64733   arg2 = (Dali::KeyEvent *)jarg2;
64734   if (!arg2) {
64735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64736     return 0;
64737   }
64738   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64739   if (!darg) {
64740     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64741     return 0;
64742   }
64743   {
64744     try {
64745       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64746     } catch (std::out_of_range& e) {
64747       {
64748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64749       };
64750     } catch (std::exception& e) {
64751       {
64752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64753       };
64754     } catch (Dali::DaliException e) {
64755       {
64756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64757       };
64758     } catch (...) {
64759       {
64760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64761       };
64762     }
64763   }
64764
64765   jresult = result;
64766   return jresult;
64767 }
64768
64769
64770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64771   unsigned int jresult ;
64772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64773   Dali::KeyEvent *arg2 = 0 ;
64774   SwigDirector_ViewImpl *darg = 0;
64775   bool result;
64776
64777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64778   arg2 = (Dali::KeyEvent *)jarg2;
64779   if (!arg2) {
64780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64781     return 0;
64782   }
64783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64784   if (!darg) {
64785     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64786     return 0;
64787   }
64788   {
64789     try {
64790       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64791     } catch (std::out_of_range& e) {
64792       {
64793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64794       };
64795     } catch (std::exception& e) {
64796       {
64797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64798       };
64799     } catch (Dali::DaliException e) {
64800       {
64801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64802       };
64803     } catch (...) {
64804       {
64805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64806       };
64807     }
64808   }
64809
64810   jresult = result;
64811   return jresult;
64812 }
64813
64814
64815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64816   unsigned int jresult ;
64817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64818   Dali::WheelEvent *arg2 = 0 ;
64819   SwigDirector_ViewImpl *darg = 0;
64820   bool result;
64821
64822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64823   arg2 = (Dali::WheelEvent *)jarg2;
64824   if (!arg2) {
64825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64826     return 0;
64827   }
64828   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64829   if (!darg) {
64830     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64831     return 0;
64832   }
64833   {
64834     try {
64835       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64836     } catch (std::out_of_range& e) {
64837       {
64838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64839       };
64840     } catch (std::exception& e) {
64841       {
64842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64843       };
64844     } catch (Dali::DaliException e) {
64845       {
64846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64847       };
64848     } catch (...) {
64849       {
64850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64851       };
64852     }
64853   }
64854
64855   jresult = result;
64856   return jresult;
64857 }
64858
64859
64860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64861   unsigned int jresult ;
64862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64863   Dali::WheelEvent *arg2 = 0 ;
64864   SwigDirector_ViewImpl *darg = 0;
64865   bool result;
64866
64867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64868   arg2 = (Dali::WheelEvent *)jarg2;
64869   if (!arg2) {
64870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64871     return 0;
64872   }
64873   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64874   if (!darg) {
64875     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64876     return 0;
64877   }
64878   {
64879     try {
64880       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64881     } catch (std::out_of_range& e) {
64882       {
64883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64884       };
64885     } catch (std::exception& e) {
64886       {
64887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64888       };
64889     } catch (Dali::DaliException e) {
64890       {
64891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64892       };
64893     } catch (...) {
64894       {
64895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64896       };
64897     }
64898   }
64899
64900   jresult = result;
64901   return jresult;
64902 }
64903
64904
64905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64907   Dali::Vector2 *arg2 = 0 ;
64908   Dali::RelayoutContainer *arg3 = 0 ;
64909   SwigDirector_ViewImpl *darg = 0;
64910
64911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64912   arg2 = (Dali::Vector2 *)jarg2;
64913   if (!arg2) {
64914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64915     return ;
64916   }
64917   arg3 = (Dali::RelayoutContainer *)jarg3;
64918   if (!arg3) {
64919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64920     return ;
64921   }
64922   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64923   if (!darg) {
64924     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64925     return;
64926   }
64927   {
64928     try {
64929       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64930     } catch (std::out_of_range& e) {
64931       {
64932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64933       };
64934     } catch (std::exception& e) {
64935       {
64936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64937       };
64938     } catch (Dali::DaliException e) {
64939       {
64940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64941       };
64942     } catch (...) {
64943       {
64944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64945       };
64946     }
64947   }
64948
64949 }
64950
64951
64952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64954   Dali::Vector2 *arg2 = 0 ;
64955   Dali::RelayoutContainer *arg3 = 0 ;
64956   SwigDirector_ViewImpl *darg = 0;
64957
64958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64959   arg2 = (Dali::Vector2 *)jarg2;
64960   if (!arg2) {
64961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64962     return ;
64963   }
64964   arg3 = (Dali::RelayoutContainer *)jarg3;
64965   if (!arg3) {
64966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64967     return ;
64968   }
64969   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64970   if (!darg) {
64971     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64972     return;
64973   }
64974   {
64975     try {
64976       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64977     } catch (std::out_of_range& e) {
64978       {
64979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64980       };
64981     } catch (std::exception& e) {
64982       {
64983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64984       };
64985     } catch (Dali::DaliException e) {
64986       {
64987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64988       };
64989     } catch (...) {
64990       {
64991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64992       };
64993     }
64994   }
64995
64996 }
64997
64998
64999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65001   Dali::ResizePolicy::Type arg2 ;
65002   Dali::Dimension::Type arg3 ;
65003   SwigDirector_ViewImpl *darg = 0;
65004
65005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65006   arg2 = (Dali::ResizePolicy::Type)jarg2;
65007   arg3 = (Dali::Dimension::Type)jarg3;
65008   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65009   if (!darg) {
65010     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65011     return;
65012   }
65013   {
65014     try {
65015       (darg)->OnSetResizePolicy(arg2,arg3);
65016     } catch (std::out_of_range& e) {
65017       {
65018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65019       };
65020     } catch (std::exception& e) {
65021       {
65022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65023       };
65024     } catch (Dali::DaliException e) {
65025       {
65026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65027       };
65028     } catch (...) {
65029       {
65030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65031       };
65032     }
65033   }
65034
65035 }
65036
65037
65038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65040   Dali::ResizePolicy::Type arg2 ;
65041   Dali::Dimension::Type arg3 ;
65042   SwigDirector_ViewImpl *darg = 0;
65043
65044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65045   arg2 = (Dali::ResizePolicy::Type)jarg2;
65046   arg3 = (Dali::Dimension::Type)jarg3;
65047   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65048   if (!darg) {
65049     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65050     return;
65051   }
65052   {
65053     try {
65054       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65055     } catch (std::out_of_range& e) {
65056       {
65057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65058       };
65059     } catch (std::exception& e) {
65060       {
65061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65062       };
65063     } catch (Dali::DaliException e) {
65064       {
65065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65066       };
65067     } catch (...) {
65068       {
65069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65070       };
65071     }
65072   }
65073
65074 }
65075
65076
65077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65078   void * jresult ;
65079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65080   SwigDirector_ViewImpl *darg = 0;
65081   Dali::Vector3 result;
65082
65083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65084   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65085   if (!darg) {
65086     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65087     return 0;
65088   }
65089   {
65090     try {
65091       result = (darg)->GetNaturalSize();
65092     } catch (std::out_of_range& e) {
65093       {
65094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65095       };
65096     } catch (std::exception& e) {
65097       {
65098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65099       };
65100     } catch (Dali::DaliException e) {
65101       {
65102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65103       };
65104     } catch (...) {
65105       {
65106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65107       };
65108     }
65109   }
65110
65111   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65112   return jresult;
65113 }
65114
65115
65116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65117   void * jresult ;
65118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65119   SwigDirector_ViewImpl *darg = 0;
65120   Dali::Vector3 result;
65121
65122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65123   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65124   if (!darg) {
65125     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65126     return 0;
65127   }
65128   {
65129     try {
65130       result = (darg)->GetNaturalSizeSwigPublic();
65131     } catch (std::out_of_range& e) {
65132       {
65133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65134       };
65135     } catch (std::exception& e) {
65136       {
65137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65138       };
65139     } catch (Dali::DaliException e) {
65140       {
65141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65142       };
65143     } catch (...) {
65144       {
65145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65146       };
65147     }
65148   }
65149
65150   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65151   return jresult;
65152 }
65153
65154
65155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65156   float jresult ;
65157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65158   Dali::Actor *arg2 = 0 ;
65159   Dali::Dimension::Type arg3 ;
65160   SwigDirector_ViewImpl *darg = 0;
65161   float result;
65162
65163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65164   arg2 = (Dali::Actor *)jarg2;
65165   if (!arg2) {
65166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65167     return 0;
65168   }
65169   arg3 = (Dali::Dimension::Type)jarg3;
65170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65171   if (!darg) {
65172     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65173     return 0;
65174   }
65175   {
65176     try {
65177       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65178     } catch (std::out_of_range& e) {
65179       {
65180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65181       };
65182     } catch (std::exception& e) {
65183       {
65184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65185       };
65186     } catch (Dali::DaliException e) {
65187       {
65188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65189       };
65190     } catch (...) {
65191       {
65192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65193       };
65194     }
65195   }
65196
65197   jresult = result;
65198   return jresult;
65199 }
65200
65201
65202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65203   float jresult ;
65204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65205   Dali::Actor *arg2 = 0 ;
65206   Dali::Dimension::Type arg3 ;
65207   SwigDirector_ViewImpl *darg = 0;
65208   float result;
65209
65210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65211   arg2 = (Dali::Actor *)jarg2;
65212   if (!arg2) {
65213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65214     return 0;
65215   }
65216   arg3 = (Dali::Dimension::Type)jarg3;
65217   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65218   if (!darg) {
65219     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65220     return 0;
65221   }
65222   {
65223     try {
65224       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65225     } catch (std::out_of_range& e) {
65226       {
65227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65228       };
65229     } catch (std::exception& e) {
65230       {
65231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65232       };
65233     } catch (Dali::DaliException e) {
65234       {
65235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65236       };
65237     } catch (...) {
65238       {
65239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65240       };
65241     }
65242   }
65243
65244   jresult = result;
65245   return jresult;
65246 }
65247
65248
65249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65250   float jresult ;
65251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65252   float arg2 ;
65253   SwigDirector_ViewImpl *darg = 0;
65254   float result;
65255
65256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65257   arg2 = (float)jarg2;
65258   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65259   if (!darg) {
65260     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65261     return 0;
65262   }
65263   {
65264     try {
65265       result = (float)(darg)->GetHeightForWidth(arg2);
65266     } catch (std::out_of_range& e) {
65267       {
65268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65269       };
65270     } catch (std::exception& e) {
65271       {
65272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65273       };
65274     } catch (Dali::DaliException e) {
65275       {
65276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65277       };
65278     } catch (...) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65281       };
65282     }
65283   }
65284
65285   jresult = result;
65286   return jresult;
65287 }
65288
65289
65290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65291   float jresult ;
65292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65293   float arg2 ;
65294   SwigDirector_ViewImpl *darg = 0;
65295   float result;
65296
65297   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65298   arg2 = (float)jarg2;
65299   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65300   if (!darg) {
65301     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65302     return 0;
65303   }
65304   {
65305     try {
65306       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65307     } catch (std::out_of_range& e) {
65308       {
65309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65310       };
65311     } catch (std::exception& e) {
65312       {
65313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65314       };
65315     } catch (Dali::DaliException e) {
65316       {
65317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65318       };
65319     } catch (...) {
65320       {
65321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65322       };
65323     }
65324   }
65325
65326   jresult = result;
65327   return jresult;
65328 }
65329
65330
65331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65332   float jresult ;
65333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65334   float arg2 ;
65335   SwigDirector_ViewImpl *darg = 0;
65336   float result;
65337
65338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65339   arg2 = (float)jarg2;
65340   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65341   if (!darg) {
65342     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65343     return 0;
65344   }
65345   {
65346     try {
65347       result = (float)(darg)->GetWidthForHeight(arg2);
65348     } catch (std::out_of_range& e) {
65349       {
65350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65351       };
65352     } catch (std::exception& e) {
65353       {
65354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65355       };
65356     } catch (Dali::DaliException e) {
65357       {
65358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65359       };
65360     } catch (...) {
65361       {
65362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65363       };
65364     }
65365   }
65366
65367   jresult = result;
65368   return jresult;
65369 }
65370
65371
65372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65373   float jresult ;
65374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65375   float arg2 ;
65376   SwigDirector_ViewImpl *darg = 0;
65377   float result;
65378
65379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65380   arg2 = (float)jarg2;
65381   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65382   if (!darg) {
65383     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65384     return 0;
65385   }
65386   {
65387     try {
65388       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65389     } catch (std::out_of_range& e) {
65390       {
65391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65392       };
65393     } catch (std::exception& e) {
65394       {
65395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (Dali::DaliException e) {
65398       {
65399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65400       };
65401     } catch (...) {
65402       {
65403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65404       };
65405     }
65406   }
65407
65408   jresult = result;
65409   return jresult;
65410 }
65411
65412
65413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65414   unsigned int jresult ;
65415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65416   Dali::Dimension::Type arg2 ;
65417   SwigDirector_ViewImpl *darg = 0;
65418   bool result;
65419
65420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65421   arg2 = (Dali::Dimension::Type)jarg2;
65422   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65423   if (!darg) {
65424     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65425     return 0;
65426   }
65427   {
65428     try {
65429       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65430     } catch (std::out_of_range& e) {
65431       {
65432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65433       };
65434     } catch (std::exception& e) {
65435       {
65436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65437       };
65438     } catch (Dali::DaliException e) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65441       };
65442     } catch (...) {
65443       {
65444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65445       };
65446     }
65447   }
65448
65449   jresult = result;
65450   return jresult;
65451 }
65452
65453
65454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65455   unsigned int jresult ;
65456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65457   Dali::Dimension::Type arg2 ;
65458   SwigDirector_ViewImpl *darg = 0;
65459   bool result;
65460
65461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65462   arg2 = (Dali::Dimension::Type)jarg2;
65463   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65464   if (!darg) {
65465     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65466     return 0;
65467   }
65468   {
65469     try {
65470       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65471     } catch (std::out_of_range& e) {
65472       {
65473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65474       };
65475     } catch (std::exception& e) {
65476       {
65477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65478       };
65479     } catch (Dali::DaliException e) {
65480       {
65481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65482       };
65483     } catch (...) {
65484       {
65485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65486       };
65487     }
65488   }
65489
65490   jresult = result;
65491   return jresult;
65492 }
65493
65494
65495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65496   unsigned int jresult ;
65497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65498   SwigDirector_ViewImpl *darg = 0;
65499   bool result;
65500
65501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65502   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65503   if (!darg) {
65504     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65505     return 0;
65506   }
65507   {
65508     try {
65509       result = (bool)(darg)->RelayoutDependentOnChildren();
65510     } catch (std::out_of_range& e) {
65511       {
65512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65513       };
65514     } catch (std::exception& e) {
65515       {
65516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65517       };
65518     } catch (Dali::DaliException e) {
65519       {
65520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65521       };
65522     } catch (...) {
65523       {
65524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65525       };
65526     }
65527   }
65528
65529   jresult = result;
65530   return jresult;
65531 }
65532
65533
65534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65535   unsigned int jresult ;
65536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65537   SwigDirector_ViewImpl *darg = 0;
65538   bool result;
65539
65540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65541   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65542   if (!darg) {
65543     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65544     return 0;
65545   }
65546   {
65547     try {
65548       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65549     } catch (std::out_of_range& e) {
65550       {
65551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65552       };
65553     } catch (std::exception& e) {
65554       {
65555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65556       };
65557     } catch (Dali::DaliException e) {
65558       {
65559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65560       };
65561     } catch (...) {
65562       {
65563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65564       };
65565     }
65566   }
65567
65568   jresult = result;
65569   return jresult;
65570 }
65571
65572
65573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65575   Dali::Dimension::Type arg2 ;
65576   SwigDirector_ViewImpl *darg = 0;
65577
65578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65579   arg2 = (Dali::Dimension::Type)jarg2;
65580   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65581   if (!darg) {
65582     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65583     return;
65584   }
65585   {
65586     try {
65587       (darg)->OnCalculateRelayoutSize(arg2);
65588     } catch (std::out_of_range& e) {
65589       {
65590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65591       };
65592     } catch (std::exception& e) {
65593       {
65594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65595       };
65596     } catch (Dali::DaliException e) {
65597       {
65598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65599       };
65600     } catch (...) {
65601       {
65602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65603       };
65604     }
65605   }
65606
65607 }
65608
65609
65610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65612   Dali::Dimension::Type arg2 ;
65613   SwigDirector_ViewImpl *darg = 0;
65614
65615   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65616   arg2 = (Dali::Dimension::Type)jarg2;
65617   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65618   if (!darg) {
65619     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65620     return;
65621   }
65622   {
65623     try {
65624       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65625     } catch (std::out_of_range& e) {
65626       {
65627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65628       };
65629     } catch (std::exception& e) {
65630       {
65631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65632       };
65633     } catch (Dali::DaliException e) {
65634       {
65635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65636       };
65637     } catch (...) {
65638       {
65639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65640       };
65641     }
65642   }
65643
65644 }
65645
65646
65647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65649   float arg2 ;
65650   Dali::Dimension::Type arg3 ;
65651   SwigDirector_ViewImpl *darg = 0;
65652
65653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65654   arg2 = (float)jarg2;
65655   arg3 = (Dali::Dimension::Type)jarg3;
65656   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65657   if (!darg) {
65658     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65659     return;
65660   }
65661   {
65662     try {
65663       (darg)->OnLayoutNegotiated(arg2,arg3);
65664     } catch (std::out_of_range& e) {
65665       {
65666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65667       };
65668     } catch (std::exception& e) {
65669       {
65670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65671       };
65672     } catch (Dali::DaliException e) {
65673       {
65674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65675       };
65676     } catch (...) {
65677       {
65678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65679       };
65680     }
65681   }
65682
65683 }
65684
65685
65686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65688   float arg2 ;
65689   Dali::Dimension::Type arg3 ;
65690   SwigDirector_ViewImpl *darg = 0;
65691
65692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65693   arg2 = (float)jarg2;
65694   arg3 = (Dali::Dimension::Type)jarg3;
65695   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65696   if (!darg) {
65697     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65698     return;
65699   }
65700   {
65701     try {
65702       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65710       };
65711     } catch (Dali::DaliException e) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65714       };
65715     } catch (...) {
65716       {
65717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65718       };
65719     }
65720   }
65721
65722 }
65723
65724
65725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65727
65728   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65729   {
65730     try {
65731       (arg1)->OnInitialize();
65732     } catch (std::out_of_range& e) {
65733       {
65734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65735       };
65736     } catch (std::exception& e) {
65737       {
65738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65739       };
65740     } catch (Dali::DaliException e) {
65741       {
65742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65743       };
65744     } catch (...) {
65745       {
65746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65747       };
65748     }
65749   }
65750
65751 }
65752
65753
65754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65755   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65756
65757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65758   {
65759     try {
65760       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65761     } catch (std::out_of_range& e) {
65762       {
65763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65764       };
65765     } catch (std::exception& e) {
65766       {
65767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65768       };
65769     } catch (Dali::DaliException e) {
65770       {
65771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65772       };
65773     } catch (...) {
65774       {
65775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65776       };
65777     }
65778   }
65779
65780 }
65781
65782
65783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65785   Dali::Actor *arg2 = 0 ;
65786
65787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65788   arg2 = (Dali::Actor *)jarg2;
65789   if (!arg2) {
65790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65791     return ;
65792   }
65793   {
65794     try {
65795       (arg1)->OnControlChildAdd(*arg2);
65796     } catch (std::out_of_range& e) {
65797       {
65798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65799       };
65800     } catch (std::exception& e) {
65801       {
65802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65803       };
65804     } catch (Dali::DaliException e) {
65805       {
65806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65807       };
65808     } catch (...) {
65809       {
65810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65811       };
65812     }
65813   }
65814
65815 }
65816
65817
65818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65819   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65820   Dali::Actor *arg2 = 0 ;
65821
65822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65823   arg2 = (Dali::Actor *)jarg2;
65824   if (!arg2) {
65825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65826     return ;
65827   }
65828   {
65829     try {
65830       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65831     } catch (std::out_of_range& e) {
65832       {
65833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65834       };
65835     } catch (std::exception& e) {
65836       {
65837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65838       };
65839     } catch (Dali::DaliException e) {
65840       {
65841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65842       };
65843     } catch (...) {
65844       {
65845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65846       };
65847     }
65848   }
65849
65850 }
65851
65852
65853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65855   Dali::Actor *arg2 = 0 ;
65856
65857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65858   arg2 = (Dali::Actor *)jarg2;
65859   if (!arg2) {
65860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65861     return ;
65862   }
65863   {
65864     try {
65865       (arg1)->OnControlChildRemove(*arg2);
65866     } catch (std::out_of_range& e) {
65867       {
65868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65869       };
65870     } catch (std::exception& e) {
65871       {
65872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65873       };
65874     } catch (Dali::DaliException e) {
65875       {
65876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65877       };
65878     } catch (...) {
65879       {
65880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65881       };
65882     }
65883   }
65884
65885 }
65886
65887
65888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65890   Dali::Actor *arg2 = 0 ;
65891
65892   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65893   arg2 = (Dali::Actor *)jarg2;
65894   if (!arg2) {
65895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65896     return ;
65897   }
65898   {
65899     try {
65900       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65901     } catch (std::out_of_range& e) {
65902       {
65903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65904       };
65905     } catch (std::exception& e) {
65906       {
65907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65908       };
65909     } catch (Dali::DaliException e) {
65910       {
65911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65912       };
65913     } catch (...) {
65914       {
65915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65916       };
65917     }
65918   }
65919
65920 }
65921
65922
65923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65925   Dali::Toolkit::StyleManager arg2 ;
65926   Dali::StyleChange::Type arg3 ;
65927   Dali::Toolkit::StyleManager *argp2 ;
65928
65929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65930   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65931   if (!argp2) {
65932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65933     return ;
65934   }
65935   arg2 = *argp2;
65936   arg3 = (Dali::StyleChange::Type)jarg3;
65937   {
65938     try {
65939       (arg1)->OnStyleChange(arg2,arg3);
65940     } catch (std::out_of_range& e) {
65941       {
65942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65943       };
65944     } catch (std::exception& e) {
65945       {
65946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65947       };
65948     } catch (Dali::DaliException e) {
65949       {
65950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65951       };
65952     } catch (...) {
65953       {
65954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65955       };
65956     }
65957   }
65958
65959 }
65960
65961
65962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65964   Dali::Toolkit::StyleManager arg2 ;
65965   Dali::StyleChange::Type arg3 ;
65966   Dali::Toolkit::StyleManager *argp2 ;
65967
65968   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65969   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65970   if (!argp2) {
65971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65972     return ;
65973   }
65974   arg2 = *argp2;
65975   arg3 = (Dali::StyleChange::Type)jarg3;
65976   {
65977     try {
65978       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65979     } catch (std::out_of_range& e) {
65980       {
65981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65982       };
65983     } catch (std::exception& e) {
65984       {
65985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65986       };
65987     } catch (Dali::DaliException e) {
65988       {
65989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65990       };
65991     } catch (...) {
65992       {
65993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65994       };
65995     }
65996   }
65997
65998 }
65999
66000
66001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66002   unsigned int jresult ;
66003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66004   bool result;
66005
66006   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66007   {
66008     try {
66009       result = (bool)(arg1)->OnAccessibilityActivated();
66010     } catch (std::out_of_range& e) {
66011       {
66012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66013       };
66014     } catch (std::exception& e) {
66015       {
66016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66017       };
66018     } catch (Dali::DaliException e) {
66019       {
66020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66021       };
66022     } catch (...) {
66023       {
66024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66025       };
66026     }
66027   }
66028
66029   jresult = result;
66030   return jresult;
66031 }
66032
66033
66034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66035   unsigned int jresult ;
66036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66037   bool result;
66038
66039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66040   {
66041     try {
66042       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66043     } catch (std::out_of_range& e) {
66044       {
66045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66046       };
66047     } catch (std::exception& e) {
66048       {
66049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66050       };
66051     } catch (Dali::DaliException e) {
66052       {
66053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66054       };
66055     } catch (...) {
66056       {
66057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66058       };
66059     }
66060   }
66061
66062   jresult = result;
66063   return jresult;
66064 }
66065
66066
66067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66068   unsigned int jresult ;
66069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66070   Dali::PanGesture arg2 ;
66071   Dali::PanGesture *argp2 ;
66072   bool result;
66073
66074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66075   argp2 = (Dali::PanGesture *)jarg2;
66076   if (!argp2) {
66077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66078     return 0;
66079   }
66080   arg2 = *argp2;
66081   {
66082     try {
66083       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66084     } catch (std::out_of_range& e) {
66085       {
66086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66087       };
66088     } catch (std::exception& e) {
66089       {
66090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66091       };
66092     } catch (Dali::DaliException e) {
66093       {
66094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66095       };
66096     } catch (...) {
66097       {
66098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66099       };
66100     }
66101   }
66102
66103   jresult = result;
66104   return jresult;
66105 }
66106
66107
66108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66109   unsigned int jresult ;
66110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66111   Dali::PanGesture arg2 ;
66112   Dali::PanGesture *argp2 ;
66113   bool result;
66114
66115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66116   argp2 = (Dali::PanGesture *)jarg2;
66117   if (!argp2) {
66118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66119     return 0;
66120   }
66121   arg2 = *argp2;
66122   {
66123     try {
66124       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66125     } catch (std::out_of_range& e) {
66126       {
66127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66128       };
66129     } catch (std::exception& e) {
66130       {
66131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66132       };
66133     } catch (Dali::DaliException e) {
66134       {
66135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66136       };
66137     } catch (...) {
66138       {
66139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66140       };
66141     }
66142   }
66143
66144   jresult = result;
66145   return jresult;
66146 }
66147
66148
66149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66150   unsigned int jresult ;
66151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66152   Dali::TouchEvent *arg2 = 0 ;
66153   bool result;
66154
66155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66156   arg2 = (Dali::TouchEvent *)jarg2;
66157   if (!arg2) {
66158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66159     return 0;
66160   }
66161   {
66162     try {
66163       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66164     } catch (std::out_of_range& e) {
66165       {
66166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66167       };
66168     } catch (std::exception& e) {
66169       {
66170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66171       };
66172     } catch (Dali::DaliException e) {
66173       {
66174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66175       };
66176     } catch (...) {
66177       {
66178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66179       };
66180     }
66181   }
66182
66183   jresult = result;
66184   return jresult;
66185 }
66186
66187
66188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66189   unsigned int jresult ;
66190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66191   Dali::TouchEvent *arg2 = 0 ;
66192   bool result;
66193
66194   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66195   arg2 = (Dali::TouchEvent *)jarg2;
66196   if (!arg2) {
66197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66198     return 0;
66199   }
66200   {
66201     try {
66202       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66203     } catch (std::out_of_range& e) {
66204       {
66205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66206       };
66207     } catch (std::exception& e) {
66208       {
66209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66210       };
66211     } catch (Dali::DaliException e) {
66212       {
66213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66214       };
66215     } catch (...) {
66216       {
66217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66218       };
66219     }
66220   }
66221
66222   jresult = result;
66223   return jresult;
66224 }
66225
66226
66227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66228   unsigned int jresult ;
66229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66230   bool arg2 ;
66231   bool result;
66232
66233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66234   arg2 = jarg2 ? true : false;
66235   {
66236     try {
66237       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66238     } catch (std::out_of_range& e) {
66239       {
66240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66241       };
66242     } catch (std::exception& e) {
66243       {
66244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66245       };
66246     } catch (Dali::DaliException e) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66249       };
66250     } catch (...) {
66251       {
66252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66253       };
66254     }
66255   }
66256
66257   jresult = result;
66258   return jresult;
66259 }
66260
66261
66262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66263   unsigned int jresult ;
66264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66265   bool arg2 ;
66266   bool result;
66267
66268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66269   arg2 = jarg2 ? true : false;
66270   {
66271     try {
66272       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66273     } catch (std::out_of_range& e) {
66274       {
66275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66276       };
66277     } catch (std::exception& e) {
66278       {
66279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66280       };
66281     } catch (Dali::DaliException e) {
66282       {
66283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66284       };
66285     } catch (...) {
66286       {
66287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66288       };
66289     }
66290   }
66291
66292   jresult = result;
66293   return jresult;
66294 }
66295
66296
66297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66298   unsigned int jresult ;
66299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66300   bool result;
66301
66302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66303   {
66304     try {
66305       result = (bool)(arg1)->OnAccessibilityZoom();
66306     } catch (std::out_of_range& e) {
66307       {
66308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66309       };
66310     } catch (std::exception& e) {
66311       {
66312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66313       };
66314     } catch (Dali::DaliException e) {
66315       {
66316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66317       };
66318     } catch (...) {
66319       {
66320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66321       };
66322     }
66323   }
66324
66325   jresult = result;
66326   return jresult;
66327 }
66328
66329
66330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66331   unsigned int jresult ;
66332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66333   bool result;
66334
66335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66336   {
66337     try {
66338       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66339     } catch (std::out_of_range& e) {
66340       {
66341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66342       };
66343     } catch (std::exception& e) {
66344       {
66345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66346       };
66347     } catch (Dali::DaliException e) {
66348       {
66349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66350       };
66351     } catch (...) {
66352       {
66353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66354       };
66355     }
66356   }
66357
66358   jresult = result;
66359   return jresult;
66360 }
66361
66362
66363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66365
66366   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66367   {
66368     try {
66369       (arg1)->OnKeyInputFocusGained();
66370     } catch (std::out_of_range& e) {
66371       {
66372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66373       };
66374     } catch (std::exception& e) {
66375       {
66376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66377       };
66378     } catch (Dali::DaliException e) {
66379       {
66380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66381       };
66382     } catch (...) {
66383       {
66384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66385       };
66386     }
66387   }
66388
66389 }
66390
66391
66392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66393   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66394
66395   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66396   {
66397     try {
66398       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66399     } catch (std::out_of_range& e) {
66400       {
66401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66402       };
66403     } catch (std::exception& e) {
66404       {
66405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66406       };
66407     } catch (Dali::DaliException e) {
66408       {
66409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66410       };
66411     } catch (...) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66414       };
66415     }
66416   }
66417
66418 }
66419
66420
66421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66423
66424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66425   {
66426     try {
66427       (arg1)->OnKeyInputFocusLost();
66428     } catch (std::out_of_range& e) {
66429       {
66430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66431       };
66432     } catch (std::exception& e) {
66433       {
66434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66435       };
66436     } catch (Dali::DaliException e) {
66437       {
66438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66439       };
66440     } catch (...) {
66441       {
66442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66443       };
66444     }
66445   }
66446
66447 }
66448
66449
66450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66452
66453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66454   {
66455     try {
66456       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66457     } catch (std::out_of_range& e) {
66458       {
66459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66460       };
66461     } catch (std::exception& e) {
66462       {
66463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66464       };
66465     } catch (Dali::DaliException e) {
66466       {
66467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66468       };
66469     } catch (...) {
66470       {
66471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66472       };
66473     }
66474   }
66475
66476 }
66477
66478
66479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66480   void * jresult ;
66481   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66482   Dali::Actor arg2 ;
66483   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66484   bool arg4 ;
66485   Dali::Actor *argp2 ;
66486   Dali::Actor result;
66487
66488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66489   argp2 = (Dali::Actor *)jarg2;
66490   if (!argp2) {
66491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66492     return 0;
66493   }
66494   arg2 = *argp2;
66495   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66496   arg4 = jarg4 ? true : false;
66497   {
66498     try {
66499       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66500     } catch (std::out_of_range& e) {
66501       {
66502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66503       };
66504     } catch (std::exception& e) {
66505       {
66506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66507       };
66508     } catch (Dali::DaliException e) {
66509       {
66510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66511       };
66512     } catch (...) {
66513       {
66514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66515       };
66516     }
66517   }
66518
66519   jresult = new Dali::Actor((const Dali::Actor &)result);
66520   return jresult;
66521 }
66522
66523
66524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66525   void * jresult ;
66526   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66527   Dali::Actor arg2 ;
66528   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66529   bool arg4 ;
66530   Dali::Actor *argp2 ;
66531   Dali::Actor result;
66532
66533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66534   argp2 = (Dali::Actor *)jarg2;
66535   if (!argp2) {
66536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66537     return 0;
66538   }
66539   arg2 = *argp2;
66540   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66541   arg4 = jarg4 ? true : false;
66542   {
66543     try {
66544       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66545     } catch (std::out_of_range& e) {
66546       {
66547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66548       };
66549     } catch (std::exception& e) {
66550       {
66551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66552       };
66553     } catch (Dali::DaliException e) {
66554       {
66555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66556       };
66557     } catch (...) {
66558       {
66559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66560       };
66561     }
66562   }
66563
66564   jresult = new Dali::Actor((const Dali::Actor &)result);
66565   return jresult;
66566 }
66567
66568
66569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66571   Dali::Actor arg2 ;
66572   Dali::Actor *argp2 ;
66573
66574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66575   argp2 = (Dali::Actor *)jarg2;
66576   if (!argp2) {
66577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66578     return ;
66579   }
66580   arg2 = *argp2;
66581   {
66582     try {
66583       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66584     } catch (std::out_of_range& e) {
66585       {
66586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66587       };
66588     } catch (std::exception& e) {
66589       {
66590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66591       };
66592     } catch (Dali::DaliException e) {
66593       {
66594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66595       };
66596     } catch (...) {
66597       {
66598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66599       };
66600     }
66601   }
66602
66603 }
66604
66605
66606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66608   Dali::Actor arg2 ;
66609   Dali::Actor *argp2 ;
66610
66611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66612   argp2 = (Dali::Actor *)jarg2;
66613   if (!argp2) {
66614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66615     return ;
66616   }
66617   arg2 = *argp2;
66618   {
66619     try {
66620       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66621     } catch (std::out_of_range& e) {
66622       {
66623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66624       };
66625     } catch (std::exception& e) {
66626       {
66627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66628       };
66629     } catch (Dali::DaliException e) {
66630       {
66631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66632       };
66633     } catch (...) {
66634       {
66635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66636       };
66637     }
66638   }
66639
66640 }
66641
66642
66643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66644   unsigned int jresult ;
66645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66646   bool result;
66647
66648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66649   {
66650     try {
66651       result = (bool)(arg1)->OnKeyboardEnter();
66652     } catch (std::out_of_range& e) {
66653       {
66654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66655       };
66656     } catch (std::exception& e) {
66657       {
66658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66659       };
66660     } catch (Dali::DaliException e) {
66661       {
66662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66663       };
66664     } catch (...) {
66665       {
66666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66667       };
66668     }
66669   }
66670
66671   jresult = result;
66672   return jresult;
66673 }
66674
66675
66676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66677   unsigned int jresult ;
66678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66679   bool result;
66680
66681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66682   {
66683     try {
66684       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66685     } catch (std::out_of_range& e) {
66686       {
66687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66688       };
66689     } catch (std::exception& e) {
66690       {
66691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66692       };
66693     } catch (Dali::DaliException e) {
66694       {
66695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66696       };
66697     } catch (...) {
66698       {
66699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66700       };
66701     }
66702   }
66703
66704   jresult = result;
66705   return jresult;
66706 }
66707
66708
66709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66711   Dali::PinchGesture *arg2 = 0 ;
66712
66713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66714   arg2 = (Dali::PinchGesture *)jarg2;
66715   if (!arg2) {
66716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66717     return ;
66718   }
66719   {
66720     try {
66721       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66722     } catch (std::out_of_range& e) {
66723       {
66724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66725       };
66726     } catch (std::exception& e) {
66727       {
66728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66729       };
66730     } catch (Dali::DaliException e) {
66731       {
66732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66733       };
66734     } catch (...) {
66735       {
66736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66737       };
66738     }
66739   }
66740
66741 }
66742
66743
66744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66746   Dali::PinchGesture *arg2 = 0 ;
66747
66748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66749   arg2 = (Dali::PinchGesture *)jarg2;
66750   if (!arg2) {
66751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66752     return ;
66753   }
66754   {
66755     try {
66756       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66757     } catch (std::out_of_range& e) {
66758       {
66759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66760       };
66761     } catch (std::exception& e) {
66762       {
66763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66764       };
66765     } catch (Dali::DaliException e) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66768       };
66769     } catch (...) {
66770       {
66771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66772       };
66773     }
66774   }
66775
66776 }
66777
66778
66779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66781   Dali::PanGesture *arg2 = 0 ;
66782
66783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66784   arg2 = (Dali::PanGesture *)jarg2;
66785   if (!arg2) {
66786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66787     return ;
66788   }
66789   {
66790     try {
66791       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66792     } catch (std::out_of_range& e) {
66793       {
66794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66795       };
66796     } catch (std::exception& e) {
66797       {
66798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66799       };
66800     } catch (Dali::DaliException e) {
66801       {
66802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66803       };
66804     } catch (...) {
66805       {
66806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66807       };
66808     }
66809   }
66810
66811 }
66812
66813
66814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66816   Dali::PanGesture *arg2 = 0 ;
66817
66818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66819   arg2 = (Dali::PanGesture *)jarg2;
66820   if (!arg2) {
66821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66822     return ;
66823   }
66824   {
66825     try {
66826       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66827     } catch (std::out_of_range& e) {
66828       {
66829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66830       };
66831     } catch (std::exception& e) {
66832       {
66833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66834       };
66835     } catch (Dali::DaliException e) {
66836       {
66837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66838       };
66839     } catch (...) {
66840       {
66841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66842       };
66843     }
66844   }
66845
66846 }
66847
66848
66849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66851   Dali::TapGesture *arg2 = 0 ;
66852
66853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66854   arg2 = (Dali::TapGesture *)jarg2;
66855   if (!arg2) {
66856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66857     return ;
66858   }
66859   {
66860     try {
66861       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66862     } catch (std::out_of_range& e) {
66863       {
66864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66865       };
66866     } catch (std::exception& e) {
66867       {
66868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66869       };
66870     } catch (Dali::DaliException e) {
66871       {
66872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66873       };
66874     } catch (...) {
66875       {
66876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66877       };
66878     }
66879   }
66880
66881 }
66882
66883
66884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66886   Dali::TapGesture *arg2 = 0 ;
66887
66888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66889   arg2 = (Dali::TapGesture *)jarg2;
66890   if (!arg2) {
66891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66892     return ;
66893   }
66894   {
66895     try {
66896       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66897     } catch (std::out_of_range& e) {
66898       {
66899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66900       };
66901     } catch (std::exception& e) {
66902       {
66903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66904       };
66905     } catch (Dali::DaliException e) {
66906       {
66907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66908       };
66909     } catch (...) {
66910       {
66911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66912       };
66913     }
66914   }
66915
66916 }
66917
66918
66919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66921   Dali::LongPressGesture *arg2 = 0 ;
66922
66923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66924   arg2 = (Dali::LongPressGesture *)jarg2;
66925   if (!arg2) {
66926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66927     return ;
66928   }
66929   {
66930     try {
66931       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66932     } catch (std::out_of_range& e) {
66933       {
66934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66935       };
66936     } catch (std::exception& e) {
66937       {
66938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66939       };
66940     } catch (Dali::DaliException e) {
66941       {
66942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66943       };
66944     } catch (...) {
66945       {
66946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66947       };
66948     }
66949   }
66950
66951 }
66952
66953
66954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66956   Dali::LongPressGesture *arg2 = 0 ;
66957
66958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66959   arg2 = (Dali::LongPressGesture *)jarg2;
66960   if (!arg2) {
66961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66962     return ;
66963   }
66964   {
66965     try {
66966       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66967     } catch (std::out_of_range& e) {
66968       {
66969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66970       };
66971     } catch (std::exception& e) {
66972       {
66973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66974       };
66975     } catch (Dali::DaliException e) {
66976       {
66977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66978       };
66979     } catch (...) {
66980       {
66981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66982       };
66983     }
66984   }
66985
66986 }
66987
66988
66989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66991   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66992   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66993
66994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66995   arg2 = (Dali::SlotObserver *)jarg2;
66996   arg3 = (Dali::CallbackBase *)jarg3;
66997   {
66998     try {
66999       (arg1)->SignalConnected(arg2,arg3);
67000     } catch (std::out_of_range& e) {
67001       {
67002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67003       };
67004     } catch (std::exception& e) {
67005       {
67006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67007       };
67008     } catch (Dali::DaliException e) {
67009       {
67010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67011       };
67012     } catch (...) {
67013       {
67014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67015       };
67016     }
67017   }
67018
67019 }
67020
67021
67022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67024   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67025   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67026
67027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67028   arg2 = (Dali::SlotObserver *)jarg2;
67029   arg3 = (Dali::CallbackBase *)jarg3;
67030   {
67031     try {
67032       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67033     } catch (std::out_of_range& e) {
67034       {
67035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67036       };
67037     } catch (std::exception& e) {
67038       {
67039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67040       };
67041     } catch (Dali::DaliException e) {
67042       {
67043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67044       };
67045     } catch (...) {
67046       {
67047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67048       };
67049     }
67050   }
67051
67052 }
67053
67054
67055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67057   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67058   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67059
67060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67061   arg2 = (Dali::SlotObserver *)jarg2;
67062   arg3 = (Dali::CallbackBase *)jarg3;
67063   {
67064     try {
67065       (arg1)->SignalDisconnected(arg2,arg3);
67066     } catch (std::out_of_range& e) {
67067       {
67068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67069       };
67070     } catch (std::exception& e) {
67071       {
67072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67073       };
67074     } catch (Dali::DaliException e) {
67075       {
67076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67077       };
67078     } catch (...) {
67079       {
67080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67081       };
67082     }
67083   }
67084
67085 }
67086
67087
67088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67090   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67091   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67092
67093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67094   arg2 = (Dali::SlotObserver *)jarg2;
67095   arg3 = (Dali::CallbackBase *)jarg3;
67096   {
67097     try {
67098       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67099     } catch (std::out_of_range& e) {
67100       {
67101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67102       };
67103     } catch (std::exception& e) {
67104       {
67105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67106       };
67107     } catch (Dali::DaliException e) {
67108       {
67109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67110       };
67111     } catch (...) {
67112       {
67113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67114       };
67115     }
67116   }
67117
67118 }
67119
67120
67121 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) {
67122   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67123   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67124   if (director) {
67125     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);
67126   }
67127 }
67128
67129
67130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67131   void * jresult ;
67132   Dali::Toolkit::Control *arg1 = 0 ;
67133   Dali::Toolkit::Internal::Control *result = 0 ;
67134
67135   arg1 = (Dali::Toolkit::Control *)jarg1;
67136   if (!arg1) {
67137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67138     return 0;
67139   }
67140   {
67141     try {
67142       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67143     } catch (std::out_of_range& e) {
67144       {
67145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67146       };
67147     } catch (std::exception& e) {
67148       {
67149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67150       };
67151     } catch (Dali::DaliException e) {
67152       {
67153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67154       };
67155     } catch (...) {
67156       {
67157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67158       };
67159     }
67160   }
67161
67162   jresult = (void *)result;
67163   return jresult;
67164 }
67165
67166
67167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67168   int jresult ;
67169   int result;
67170
67171   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67172   jresult = (int)result;
67173   return jresult;
67174 }
67175
67176
67177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67178   int jresult ;
67179   int result;
67180
67181   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67182   jresult = (int)result;
67183   return jresult;
67184 }
67185
67186
67187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67188   int jresult ;
67189   int result;
67190
67191   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67192   jresult = (int)result;
67193   return jresult;
67194 }
67195
67196
67197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67198   int jresult ;
67199   int result;
67200
67201   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67202   jresult = (int)result;
67203   return jresult;
67204 }
67205
67206
67207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67208   int jresult ;
67209   int result;
67210
67211   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67212   jresult = (int)result;
67213   return jresult;
67214 }
67215
67216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67217   int jresult ;
67218   int result;
67219
67220   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67221   jresult = (int)result;
67222   return jresult;
67223 }
67224
67225
67226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67227   int jresult ;
67228   int result;
67229
67230   result = (int)Dali::Toolkit::Control::Property::PADDING;
67231   jresult = (int)result;
67232   return jresult;
67233 }
67234
67235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67236   void * jresult ;
67237   Dali::Toolkit::Control::Property *result = 0 ;
67238
67239   {
67240     try {
67241       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67242     } catch (std::out_of_range& e) {
67243       {
67244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67245       };
67246     } catch (std::exception& e) {
67247       {
67248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67249       };
67250     } catch (Dali::DaliException e) {
67251       {
67252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67253       };
67254     } catch (...) {
67255       {
67256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67257       };
67258     }
67259   }
67260
67261   jresult = (void *)result;
67262   return jresult;
67263 }
67264
67265
67266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67267   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67268
67269   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67270   {
67271     try {
67272       delete arg1;
67273     } catch (std::out_of_range& e) {
67274       {
67275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67276       };
67277     } catch (std::exception& e) {
67278       {
67279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67280       };
67281     } catch (Dali::DaliException e) {
67282       {
67283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67284       };
67285     } catch (...) {
67286       {
67287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67288       };
67289     }
67290   }
67291
67292 }
67293
67294
67295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67296   void * jresult ;
67297   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67298
67299   {
67300     try {
67301       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67302     } catch (std::out_of_range& e) {
67303       {
67304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67305       };
67306     } catch (std::exception& e) {
67307       {
67308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67309       };
67310     } catch (Dali::DaliException e) {
67311       {
67312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67313       };
67314     } catch (...) {
67315       {
67316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67317       };
67318     }
67319   }
67320
67321   jresult = (void *)result;
67322   return jresult;
67323 }
67324
67325
67326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67327   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67328
67329   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67330   {
67331     try {
67332       delete arg1;
67333     } catch (std::out_of_range& e) {
67334       {
67335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67336       };
67337     } catch (std::exception& e) {
67338       {
67339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67340       };
67341     } catch (Dali::DaliException e) {
67342       {
67343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67344       };
67345     } catch (...) {
67346       {
67347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67348       };
67349     }
67350   }
67351
67352 }
67353
67354
67355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67356   void * jresult ;
67357   Dali::Toolkit::Control result;
67358
67359   {
67360     try {
67361       result = Dali::Toolkit::Control::New();
67362     } catch (std::out_of_range& e) {
67363       {
67364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67365       };
67366     } catch (std::exception& e) {
67367       {
67368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67369       };
67370     } catch (Dali::DaliException e) {
67371       {
67372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67373       };
67374     } catch (...) {
67375       {
67376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67377       };
67378     }
67379   }
67380
67381   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67382   return jresult;
67383 }
67384
67385
67386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67387   void * jresult ;
67388   Dali::Toolkit::Control *result = 0 ;
67389
67390   {
67391     try {
67392       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67393     } catch (std::out_of_range& e) {
67394       {
67395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67396       };
67397     } catch (std::exception& e) {
67398       {
67399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67400       };
67401     } catch (Dali::DaliException e) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67404       };
67405     } catch (...) {
67406       {
67407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67408       };
67409     }
67410   }
67411
67412   jresult = (void *)result;
67413   return jresult;
67414 }
67415
67416
67417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67418   void * jresult ;
67419   Dali::Toolkit::Control *arg1 = 0 ;
67420   Dali::Toolkit::Control *result = 0 ;
67421
67422   arg1 = (Dali::Toolkit::Control *)jarg1;
67423   if (!arg1) {
67424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67425     return 0;
67426   }
67427   {
67428     try {
67429       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67430     } catch (std::out_of_range& e) {
67431       {
67432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67433       };
67434     } catch (std::exception& e) {
67435       {
67436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67437       };
67438     } catch (Dali::DaliException e) {
67439       {
67440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67441       };
67442     } catch (...) {
67443       {
67444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67445       };
67446     }
67447   }
67448
67449   jresult = (void *)result;
67450   return jresult;
67451 }
67452
67453
67454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67455   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67456
67457   arg1 = (Dali::Toolkit::Control *)jarg1;
67458   {
67459     try {
67460       delete arg1;
67461     } catch (std::out_of_range& e) {
67462       {
67463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67464       };
67465     } catch (std::exception& e) {
67466       {
67467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67468       };
67469     } catch (Dali::DaliException e) {
67470       {
67471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67472       };
67473     } catch (...) {
67474       {
67475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67476       };
67477     }
67478   }
67479
67480 }
67481
67482
67483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67484   void * jresult ;
67485   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67486   Dali::Toolkit::Control *arg2 = 0 ;
67487   Dali::Toolkit::Control *result = 0 ;
67488
67489   arg1 = (Dali::Toolkit::Control *)jarg1;
67490   arg2 = (Dali::Toolkit::Control *)jarg2;
67491   if (!arg2) {
67492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67493     return 0;
67494   }
67495   {
67496     try {
67497       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67498     } catch (std::out_of_range& e) {
67499       {
67500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (std::exception& e) {
67503       {
67504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67505       };
67506     } catch (Dali::DaliException e) {
67507       {
67508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67509       };
67510     } catch (...) {
67511       {
67512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67513       };
67514     }
67515   }
67516
67517   jresult = (void *)result;
67518   return jresult;
67519 }
67520
67521
67522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67523   void * jresult ;
67524   Dali::BaseHandle arg1 ;
67525   Dali::BaseHandle *argp1 ;
67526   Dali::Toolkit::Control result;
67527
67528   argp1 = (Dali::BaseHandle *)jarg1;
67529   if (!argp1) {
67530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67531     return 0;
67532   }
67533   arg1 = *argp1;
67534   {
67535     try {
67536       result = Dali::Toolkit::Control::DownCast(arg1);
67537     } catch (std::out_of_range& e) {
67538       {
67539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67540       };
67541     } catch (std::exception& e) {
67542       {
67543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67544       };
67545     } catch (Dali::DaliException e) {
67546       {
67547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67548       };
67549     } catch (...) {
67550       {
67551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67552       };
67553     }
67554   }
67555
67556   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67557   return jresult;
67558 }
67559
67560
67561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67562   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67563
67564   arg1 = (Dali::Toolkit::Control *)jarg1;
67565   {
67566     try {
67567       (arg1)->SetKeyInputFocus();
67568     } catch (std::out_of_range& e) {
67569       {
67570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67571       };
67572     } catch (std::exception& e) {
67573       {
67574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67575       };
67576     } catch (Dali::DaliException e) {
67577       {
67578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67579       };
67580     } catch (...) {
67581       {
67582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67583       };
67584     }
67585   }
67586
67587 }
67588
67589
67590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67591   unsigned int jresult ;
67592   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67593   bool result;
67594
67595   arg1 = (Dali::Toolkit::Control *)jarg1;
67596   {
67597     try {
67598       result = (bool)(arg1)->HasKeyInputFocus();
67599     } catch (std::out_of_range& e) {
67600       {
67601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67602       };
67603     } catch (std::exception& e) {
67604       {
67605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67606       };
67607     } catch (Dali::DaliException e) {
67608       {
67609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67610       };
67611     } catch (...) {
67612       {
67613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67614       };
67615     }
67616   }
67617
67618   jresult = result;
67619   return jresult;
67620 }
67621
67622
67623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67624   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67625
67626   arg1 = (Dali::Toolkit::Control *)jarg1;
67627   {
67628     try {
67629       (arg1)->ClearKeyInputFocus();
67630     } catch (std::out_of_range& e) {
67631       {
67632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67633       };
67634     } catch (std::exception& e) {
67635       {
67636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67637       };
67638     } catch (Dali::DaliException e) {
67639       {
67640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67641       };
67642     } catch (...) {
67643       {
67644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67645       };
67646     }
67647   }
67648
67649 }
67650
67651
67652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67653   void * jresult ;
67654   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67655   Dali::PinchGestureDetector result;
67656
67657   arg1 = (Dali::Toolkit::Control *)jarg1;
67658   {
67659     try {
67660       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67661     } catch (std::out_of_range& e) {
67662       {
67663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67664       };
67665     } catch (std::exception& e) {
67666       {
67667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67668       };
67669     } catch (Dali::DaliException e) {
67670       {
67671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67672       };
67673     } catch (...) {
67674       {
67675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67676       };
67677     }
67678   }
67679
67680   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67681   return jresult;
67682 }
67683
67684
67685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67686   void * jresult ;
67687   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67688   Dali::PanGestureDetector result;
67689
67690   arg1 = (Dali::Toolkit::Control *)jarg1;
67691   {
67692     try {
67693       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67694     } catch (std::out_of_range& e) {
67695       {
67696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67697       };
67698     } catch (std::exception& e) {
67699       {
67700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67701       };
67702     } catch (Dali::DaliException e) {
67703       {
67704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67705       };
67706     } catch (...) {
67707       {
67708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67709       };
67710     }
67711   }
67712
67713   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67714   return jresult;
67715 }
67716
67717
67718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67719   void * jresult ;
67720   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67721   Dali::TapGestureDetector result;
67722
67723   arg1 = (Dali::Toolkit::Control *)jarg1;
67724   {
67725     try {
67726       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67727     } catch (std::out_of_range& e) {
67728       {
67729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67730       };
67731     } catch (std::exception& e) {
67732       {
67733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67734       };
67735     } catch (Dali::DaliException e) {
67736       {
67737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67738       };
67739     } catch (...) {
67740       {
67741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67742       };
67743     }
67744   }
67745
67746   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67747   return jresult;
67748 }
67749
67750
67751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67752   void * jresult ;
67753   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67754   Dali::LongPressGestureDetector result;
67755
67756   arg1 = (Dali::Toolkit::Control *)jarg1;
67757   {
67758     try {
67759       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67760     } catch (std::out_of_range& e) {
67761       {
67762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67763       };
67764     } catch (std::exception& e) {
67765       {
67766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67767       };
67768     } catch (Dali::DaliException e) {
67769       {
67770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67771       };
67772     } catch (...) {
67773       {
67774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67775       };
67776     }
67777   }
67778
67779   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67780   return jresult;
67781 }
67782
67783
67784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67785   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67786   std::string *arg2 = 0 ;
67787
67788   arg1 = (Dali::Toolkit::Control *)jarg1;
67789   if (!jarg2) {
67790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67791     return ;
67792   }
67793   std::string arg2_str(jarg2);
67794   arg2 = &arg2_str;
67795   {
67796     try {
67797       (arg1)->SetStyleName((std::string const &)*arg2);
67798     } catch (std::out_of_range& e) {
67799       {
67800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67801       };
67802     } catch (std::exception& e) {
67803       {
67804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67805       };
67806     } catch (Dali::DaliException e) {
67807       {
67808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67809       };
67810     } catch (...) {
67811       {
67812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67813       };
67814     }
67815   }
67816
67817
67818   //argout typemap for const std::string&
67819
67820 }
67821
67822
67823 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67824   char * jresult ;
67825   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67826   std::string *result = 0 ;
67827
67828   arg1 = (Dali::Toolkit::Control *)jarg1;
67829   {
67830     try {
67831       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67832     } catch (std::out_of_range& e) {
67833       {
67834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67835       };
67836     } catch (std::exception& e) {
67837       {
67838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67839       };
67840     } catch (Dali::DaliException e) {
67841       {
67842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67843       };
67844     } catch (...) {
67845       {
67846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67847       };
67848     }
67849   }
67850
67851   jresult = SWIG_csharp_string_callback(result->c_str());
67852   return jresult;
67853 }
67854
67855
67856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67857   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67858   Dali::Vector4 *arg2 = 0 ;
67859
67860   arg1 = (Dali::Toolkit::Control *)jarg1;
67861   arg2 = (Dali::Vector4 *)jarg2;
67862   if (!arg2) {
67863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67864     return ;
67865   }
67866   {
67867     try {
67868       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67869     } catch (std::out_of_range& e) {
67870       {
67871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67872       };
67873     } catch (std::exception& e) {
67874       {
67875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67876       };
67877     } catch (Dali::DaliException e) {
67878       {
67879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67880       };
67881     } catch (...) {
67882       {
67883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67884       };
67885     }
67886   }
67887
67888 }
67889
67890
67891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67892   void * jresult ;
67893   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67894   Dali::Vector4 result;
67895
67896   arg1 = (Dali::Toolkit::Control *)jarg1;
67897   {
67898     try {
67899       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67900     } catch (std::out_of_range& e) {
67901       {
67902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67903       };
67904     } catch (std::exception& e) {
67905       {
67906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67907       };
67908     } catch (Dali::DaliException e) {
67909       {
67910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67911       };
67912     } catch (...) {
67913       {
67914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67915       };
67916     }
67917   }
67918
67919   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67920   return jresult;
67921 }
67922
67923
67924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67925   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67926   Dali::Image arg2 ;
67927   Dali::Image *argp2 ;
67928
67929   arg1 = (Dali::Toolkit::Control *)jarg1;
67930   argp2 = (Dali::Image *)jarg2;
67931   if (!argp2) {
67932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67933     return ;
67934   }
67935   arg2 = *argp2;
67936   {
67937     try {
67938       (arg1)->SetBackgroundImage(arg2);
67939     } catch (std::out_of_range& e) {
67940       {
67941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67942       };
67943     } catch (std::exception& e) {
67944       {
67945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67946       };
67947     } catch (Dali::DaliException e) {
67948       {
67949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67950       };
67951     } catch (...) {
67952       {
67953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67954       };
67955     }
67956   }
67957
67958 }
67959
67960
67961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67962   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67963
67964   arg1 = (Dali::Toolkit::Control *)jarg1;
67965   {
67966     try {
67967       (arg1)->ClearBackground();
67968     } catch (std::out_of_range& e) {
67969       {
67970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67971       };
67972     } catch (std::exception& e) {
67973       {
67974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67975       };
67976     } catch (Dali::DaliException e) {
67977       {
67978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67979       };
67980     } catch (...) {
67981       {
67982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67983       };
67984     }
67985   }
67986
67987 }
67988
67989
67990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67991   void * jresult ;
67992   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67993   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67994
67995   arg1 = (Dali::Toolkit::Control *)jarg1;
67996   {
67997     try {
67998       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67999     } catch (std::out_of_range& e) {
68000       {
68001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68002       };
68003     } catch (std::exception& e) {
68004       {
68005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68006       };
68007     } catch (Dali::DaliException e) {
68008       {
68009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68010       };
68011     } catch (...) {
68012       {
68013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68014       };
68015     }
68016   }
68017
68018   jresult = (void *)result;
68019   return jresult;
68020 }
68021
68022
68023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68024   void * jresult ;
68025   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68026   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68027
68028   arg1 = (Dali::Toolkit::Control *)jarg1;
68029   {
68030     try {
68031       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68032     } catch (std::out_of_range& e) {
68033       {
68034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68035       };
68036     } catch (std::exception& e) {
68037       {
68038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68039       };
68040     } catch (Dali::DaliException e) {
68041       {
68042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68043       };
68044     } catch (...) {
68045       {
68046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68047       };
68048     }
68049   }
68050
68051   jresult = (void *)result;
68052   return jresult;
68053 }
68054
68055
68056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68057   void * jresult ;
68058   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68059   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68060
68061   arg1 = (Dali::Toolkit::Control *)jarg1;
68062   {
68063     try {
68064       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68065     } catch (std::out_of_range& e) {
68066       {
68067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68068       };
68069     } catch (std::exception& e) {
68070       {
68071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68072       };
68073     } catch (Dali::DaliException e) {
68074       {
68075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68076       };
68077     } catch (...) {
68078       {
68079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68080       };
68081     }
68082   }
68083
68084   jresult = (void *)result;
68085   return jresult;
68086 }
68087
68088
68089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68090   void * jresult ;
68091   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68092   Dali::Toolkit::Control *result = 0 ;
68093
68094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68095   if (!arg1) {
68096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68097     return 0;
68098   }
68099   {
68100     try {
68101       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68102     } catch (std::out_of_range& e) {
68103       {
68104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68105       };
68106     } catch (std::exception& e) {
68107       {
68108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68109       };
68110     } catch (Dali::DaliException e) {
68111       {
68112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68113       };
68114     } catch (...) {
68115       {
68116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68117       };
68118     }
68119   }
68120
68121   jresult = (void *)result;
68122   return jresult;
68123 }
68124
68125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68126 {
68127   int jresult;
68128   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68129   arg1 = (Dali::Toolkit::Control *)jarg1;
68130
68131   if (!arg1) {
68132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68133     return 0;
68134   }
68135
68136   Dali::Property::Index arg2 = 0 ;
68137   arg2 = (Dali::Property::Index)jarg2;
68138
68139   Toolkit::Visual::ResourceStatus result;
68140   {
68141     try {
68142       result = arg1->GetVisualResourceStatus(arg2);
68143     } catch (std::out_of_range& e) {
68144       {
68145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68146       };
68147     } catch (std::exception& e) {
68148       {
68149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68150       };
68151     } catch (...) {
68152       {
68153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68154       };
68155     }
68156   }
68157   jresult = (int)(result);
68158   return jresult;
68159 }
68160
68161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68162 {
68163   void * jresult;
68164   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68165   arg1 = (Dali::Toolkit::Control *)jarg1;
68166
68167   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68168
68169   Dali::Toolkit::TransitionData *arg2 = 0 ;
68170   Dali::Animation result;
68171
68172   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68173   if (!arg2) {
68174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68175     return 0;
68176   }
68177   {
68178     try {
68179       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68180     } catch (std::out_of_range& e) {
68181       {
68182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68183       };
68184     } catch (std::exception& e) {
68185       {
68186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68187       };
68188     } catch (Dali::DaliException e) {
68189       {
68190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68191       };
68192     } catch (...) {
68193       {
68194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68195       };
68196     }
68197   }
68198
68199   jresult = new Dali::Animation((const Dali::Animation &)result);
68200   return jresult;
68201 }
68202
68203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68204 {
68205   Dali::Toolkit::Control arg1;
68206   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68207
68208   if (!argp1) {
68209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68210   }
68211   arg1 = *argp1;
68212
68213   Dali::Property::Index arg2 = 0 ;
68214   arg2 = (Dali::Property::Index)jarg2;
68215
68216   Dali::Property::Index arg3 = 0 ;
68217   arg3 = (Dali::Property::Index)jarg3;
68218
68219   Dali::Property::Value arg4;
68220   arg4 = (Dali::Property::Value *)jarg4;
68221
68222   {
68223     try {
68224       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68225     } catch (std::out_of_range& e) {
68226       {
68227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68228       };
68229     } catch (std::exception& e) {
68230       {
68231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68232       };
68233     } catch (...) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68236       };
68237     }
68238   }
68239
68240
68241 }
68242
68243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68244   void * jresult ;
68245   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68246   Dali::Toolkit::LayoutItem result;
68247
68248   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68249   if (!arg1) {
68250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68251     return 0;
68252   }
68253   {
68254     try {
68255       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68256     } catch (std::out_of_range& e) {
68257       {
68258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (std::exception& e) {
68261       {
68262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68263       };
68264     } catch (...) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68267       };
68268     }
68269   }
68270   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68271   return jresult;
68272 }
68273
68274
68275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68276   void * jresult ;
68277   Dali::Toolkit::Control arg1 ;
68278   Dali::Toolkit::Control *argp1 ;
68279   Dali::Toolkit::LayoutItem result;
68280
68281   argp1 = (Dali::Toolkit::Control *)jarg1;
68282   if (!argp1) {
68283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68284     return 0;
68285   }
68286   arg1 = *argp1;
68287   {
68288     try {
68289       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68290     } catch (std::out_of_range& e) {
68291       {
68292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68293       };
68294     } catch (std::exception& e) {
68295       {
68296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68297       };
68298     } catch (...) {
68299       {
68300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68301       };
68302     }
68303   }
68304   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68305   return jresult;
68306 }
68307
68308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68309   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68310   Dali::Toolkit::LayoutItem arg2 ;
68311   Dali::Toolkit::LayoutItem *argp2 ;
68312
68313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68314   if (!arg1) {
68315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68316     return ;
68317   }
68318   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68319   if (!argp2) {
68320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68321     return ;
68322   }
68323   arg2 = *argp2;
68324   {
68325     try {
68326       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68327     } catch (std::out_of_range& e) {
68328       {
68329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68330       };
68331     } catch (std::exception& e) {
68332       {
68333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68334       };
68335     } catch (...) {
68336       {
68337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68338       };
68339     }
68340   }
68341 }
68342
68343
68344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68345   Dali::Toolkit::Control arg1 ;
68346   Dali::Toolkit::LayoutItem arg2 ;
68347   Dali::Toolkit::Control *argp1 ;
68348   Dali::Toolkit::LayoutItem *argp2 ;
68349
68350   argp1 = (Dali::Toolkit::Control *)jarg1;
68351   if (!argp1) {
68352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68353     return ;
68354   }
68355   arg1 = *argp1;
68356   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68357   if (!argp2) {
68358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68359     return ;
68360   }
68361   arg2 = *argp2;
68362   {
68363     try {
68364       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68365     } catch (std::out_of_range& e) {
68366       {
68367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68368       };
68369     } catch (std::exception& e) {
68370       {
68371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68372       };
68373     } catch (...) {
68374       {
68375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68376       };
68377     }
68378   }
68379 }
68380
68381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayoutingRequired(void * jarg1, bool jarg2) {
68382   Dali::Toolkit::Control *arg1 = 0 ;
68383
68384   arg1 = (Dali::Toolkit::Control *)jarg1;
68385   if (!arg1) {
68386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68387     return ;
68388   }
68389
68390   {
68391     try {
68392       Dali::Toolkit::DevelControl::SetLayoutingRequired(*arg1,jarg2);
68393     } catch (std::out_of_range& e) {
68394       {
68395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68396       };
68397     } catch (std::exception& e) {
68398       {
68399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68400       };
68401     } catch (...) {
68402       {
68403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68404       };
68405     }
68406   }
68407 }
68408
68409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_IsLayoutingRequired(void * jarg1) {
68410   unsigned int jresult ;
68411   Dali::Toolkit::Control *arg1 = 0 ;
68412   bool result;
68413
68414   arg1 = (Dali::Toolkit::Control *)jarg1;
68415   if (!arg1) {
68416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68417     return 0;
68418   }
68419   {
68420     try {
68421       result = (bool)DevelControl::IsLayoutingRequired( *arg1 );
68422     } catch (std::out_of_range& e) {
68423       {
68424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68425       };
68426     } catch (std::exception& e) {
68427       {
68428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68429       };
68430     } catch (Dali::DaliException e) {
68431       {
68432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68433       };
68434     } catch (...) {
68435       {
68436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68437       };
68438     }
68439   }
68440
68441   jresult = result;
68442   return jresult;
68443 }
68444
68445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68446   void * jresult ;
68447   Dali::Toolkit::Control *arg1 = 0 ;
68448   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68449
68450   arg1 = (Dali::Toolkit::Control *)jarg1;
68451   if (!arg1) {
68452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68453     return 0;
68454   }
68455   {
68456     try {
68457       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68458     } catch (std::out_of_range& e) {
68459       {
68460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68461       };
68462     } catch (std::exception& e) {
68463       {
68464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68465       };
68466     } catch (Dali::DaliException e) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68469       };
68470     } catch (...) {
68471       {
68472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68473       };
68474     }
68475   }
68476
68477   jresult = (void *)result;
68478   return jresult;
68479 }
68480
68481
68482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68483   unsigned int jresult ;
68484   Dali::Toolkit::Control *arg1 = 0 ;
68485   bool result;
68486
68487   arg1 = (Dali::Toolkit::Control *)jarg1;
68488   if (!arg1) {
68489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68490     return 0;
68491   }
68492   {
68493     try {
68494       result = (bool)arg1->IsResourceReady();
68495     } catch (std::out_of_range& e) {
68496       {
68497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68498       };
68499     } catch (std::exception& e) {
68500       {
68501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68502       };
68503     } catch (Dali::DaliException e) {
68504       {
68505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68506       };
68507     } catch (...) {
68508       {
68509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68510       };
68511     }
68512   }
68513
68514   jresult = result;
68515   return jresult;
68516 }
68517
68518
68519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68520   void * jresult ;
68521   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68522
68523   {
68524     try {
68525       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68526     } catch (std::out_of_range& e) {
68527       {
68528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68529       };
68530     } catch (std::exception& e) {
68531       {
68532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68533       };
68534     } catch (Dali::DaliException e) {
68535       {
68536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68537       };
68538     } catch (...) {
68539       {
68540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68541       };
68542     }
68543   }
68544
68545   jresult = (void *)result;
68546   return jresult;
68547 }
68548
68549
68550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68551   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68552
68553   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68554   {
68555     try {
68556       delete arg1;
68557     } catch (std::out_of_range& e) {
68558       {
68559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68560       };
68561     } catch (std::exception& e) {
68562       {
68563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68564       };
68565     } catch (Dali::DaliException e) {
68566       {
68567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68568       };
68569     } catch (...) {
68570       {
68571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68572       };
68573     }
68574   }
68575
68576 }
68577
68578
68579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68580   void * jresult ;
68581   Dali::Toolkit::KeyInputFocusManager result;
68582
68583   {
68584     try {
68585       result = Dali::Toolkit::KeyInputFocusManager::Get();
68586     } catch (std::out_of_range& e) {
68587       {
68588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68589       };
68590     } catch (std::exception& e) {
68591       {
68592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68593       };
68594     } catch (Dali::DaliException e) {
68595       {
68596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68597       };
68598     } catch (...) {
68599       {
68600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68601       };
68602     }
68603   }
68604
68605   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68606   return jresult;
68607 }
68608
68609
68610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68611   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68612   Dali::Toolkit::Control arg2 ;
68613   Dali::Toolkit::Control *argp2 ;
68614
68615   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68616   argp2 = (Dali::Toolkit::Control *)jarg2;
68617   if (!argp2) {
68618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68619     return ;
68620   }
68621   arg2 = *argp2;
68622   {
68623     try {
68624       (arg1)->SetFocus(arg2);
68625     } catch (std::out_of_range& e) {
68626       {
68627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68628       };
68629     } catch (std::exception& e) {
68630       {
68631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68632       };
68633     } catch (Dali::DaliException e) {
68634       {
68635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68636       };
68637     } catch (...) {
68638       {
68639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68640       };
68641     }
68642   }
68643
68644 }
68645
68646
68647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68648   void * jresult ;
68649   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68650   Dali::Toolkit::Control result;
68651
68652   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68653   {
68654     try {
68655       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68656     } catch (std::out_of_range& e) {
68657       {
68658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68659       };
68660     } catch (std::exception& e) {
68661       {
68662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68663       };
68664     } catch (Dali::DaliException e) {
68665       {
68666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68667       };
68668     } catch (...) {
68669       {
68670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68671       };
68672     }
68673   }
68674
68675   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68676   return jresult;
68677 }
68678
68679
68680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68681   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68682   Dali::Toolkit::Control arg2 ;
68683   Dali::Toolkit::Control *argp2 ;
68684
68685   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68686   argp2 = (Dali::Toolkit::Control *)jarg2;
68687   if (!argp2) {
68688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68689     return ;
68690   }
68691   arg2 = *argp2;
68692   {
68693     try {
68694       (arg1)->RemoveFocus(arg2);
68695     } catch (std::out_of_range& e) {
68696       {
68697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68698       };
68699     } catch (std::exception& e) {
68700       {
68701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68702       };
68703     } catch (Dali::DaliException e) {
68704       {
68705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68706       };
68707     } catch (...) {
68708       {
68709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68710       };
68711     }
68712   }
68713
68714 }
68715
68716
68717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68718   void * jresult ;
68719   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68720   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68721
68722   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68723   {
68724     try {
68725       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68726     } catch (std::out_of_range& e) {
68727       {
68728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68729       };
68730     } catch (std::exception& e) {
68731       {
68732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68733       };
68734     } catch (Dali::DaliException e) {
68735       {
68736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68737       };
68738     } catch (...) {
68739       {
68740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68741       };
68742     }
68743   }
68744
68745   jresult = (void *)result;
68746   return jresult;
68747 }
68748
68749
68750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68751   void * jresult ;
68752   Dali::Toolkit::Alignment::Padding *result = 0 ;
68753
68754   {
68755     try {
68756       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68757     } catch (std::out_of_range& e) {
68758       {
68759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68760       };
68761     } catch (std::exception& e) {
68762       {
68763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68764       };
68765     } catch (Dali::DaliException e) {
68766       {
68767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68768       };
68769     } catch (...) {
68770       {
68771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68772       };
68773     }
68774   }
68775
68776   jresult = (void *)result;
68777   return jresult;
68778 }
68779
68780
68781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68782   void * jresult ;
68783   float arg1 ;
68784   float arg2 ;
68785   float arg3 ;
68786   float arg4 ;
68787   Dali::Toolkit::Alignment::Padding *result = 0 ;
68788
68789   arg1 = (float)jarg1;
68790   arg2 = (float)jarg2;
68791   arg3 = (float)jarg3;
68792   arg4 = (float)jarg4;
68793   {
68794     try {
68795       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68796     } catch (std::out_of_range& e) {
68797       {
68798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68799       };
68800     } catch (std::exception& e) {
68801       {
68802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68803       };
68804     } catch (Dali::DaliException e) {
68805       {
68806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68807       };
68808     } catch (...) {
68809       {
68810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68811       };
68812     }
68813   }
68814
68815   jresult = (void *)result;
68816   return jresult;
68817 }
68818
68819
68820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68821   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68822   float arg2 ;
68823
68824   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68825   arg2 = (float)jarg2;
68826   if (arg1) (arg1)->left = arg2;
68827 }
68828
68829
68830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68831   float jresult ;
68832   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68833   float result;
68834
68835   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68836   result = (float) ((arg1)->left);
68837   jresult = result;
68838   return jresult;
68839 }
68840
68841
68842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68843   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68844   float arg2 ;
68845
68846   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68847   arg2 = (float)jarg2;
68848   if (arg1) (arg1)->right = arg2;
68849 }
68850
68851
68852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68853   float jresult ;
68854   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68855   float result;
68856
68857   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68858   result = (float) ((arg1)->right);
68859   jresult = result;
68860   return jresult;
68861 }
68862
68863
68864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68865   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68866   float arg2 ;
68867
68868   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68869   arg2 = (float)jarg2;
68870   if (arg1) (arg1)->top = arg2;
68871 }
68872
68873
68874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68875   float jresult ;
68876   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68877   float result;
68878
68879   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68880   result = (float) ((arg1)->top);
68881   jresult = result;
68882   return jresult;
68883 }
68884
68885
68886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68887   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68888   float arg2 ;
68889
68890   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68891   arg2 = (float)jarg2;
68892   if (arg1) (arg1)->bottom = arg2;
68893 }
68894
68895
68896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68897   float jresult ;
68898   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68899   float result;
68900
68901   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68902   result = (float) ((arg1)->bottom);
68903   jresult = result;
68904   return jresult;
68905 }
68906
68907
68908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68909   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68910
68911   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68912   {
68913     try {
68914       delete arg1;
68915     } catch (std::out_of_range& e) {
68916       {
68917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68918       };
68919     } catch (std::exception& e) {
68920       {
68921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68922       };
68923     } catch (Dali::DaliException e) {
68924       {
68925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68926       };
68927     } catch (...) {
68928       {
68929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68930       };
68931     }
68932   }
68933
68934 }
68935
68936
68937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68938   void * jresult ;
68939   Dali::Toolkit::Alignment *result = 0 ;
68940
68941   {
68942     try {
68943       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68944     } catch (std::out_of_range& e) {
68945       {
68946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68947       };
68948     } catch (std::exception& e) {
68949       {
68950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68951       };
68952     } catch (Dali::DaliException e) {
68953       {
68954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68955       };
68956     } catch (...) {
68957       {
68958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68959       };
68960     }
68961   }
68962
68963   jresult = (void *)result;
68964   return jresult;
68965 }
68966
68967
68968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68969   void * jresult ;
68970   Dali::Toolkit::Alignment::Type arg1 ;
68971   Dali::Toolkit::Alignment::Type arg2 ;
68972   Dali::Toolkit::Alignment result;
68973
68974   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68975   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68976   {
68977     try {
68978       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68979     } catch (std::out_of_range& e) {
68980       {
68981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68982       };
68983     } catch (std::exception& e) {
68984       {
68985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68986       };
68987     } catch (Dali::DaliException e) {
68988       {
68989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68990       };
68991     } catch (...) {
68992       {
68993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68994       };
68995     }
68996   }
68997
68998   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68999   return jresult;
69000 }
69001
69002
69003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69004   void * jresult ;
69005   Dali::Toolkit::Alignment::Type arg1 ;
69006   Dali::Toolkit::Alignment result;
69007
69008   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69009   {
69010     try {
69011       result = Dali::Toolkit::Alignment::New(arg1);
69012     } catch (std::out_of_range& e) {
69013       {
69014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69015       };
69016     } catch (std::exception& e) {
69017       {
69018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69019       };
69020     } catch (Dali::DaliException e) {
69021       {
69022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69023       };
69024     } catch (...) {
69025       {
69026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69027       };
69028     }
69029   }
69030
69031   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69032   return jresult;
69033 }
69034
69035
69036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69037   void * jresult ;
69038   Dali::Toolkit::Alignment result;
69039
69040   {
69041     try {
69042       result = Dali::Toolkit::Alignment::New();
69043     } catch (std::out_of_range& e) {
69044       {
69045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69046       };
69047     } catch (std::exception& e) {
69048       {
69049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69050       };
69051     } catch (Dali::DaliException e) {
69052       {
69053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69054       };
69055     } catch (...) {
69056       {
69057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69058       };
69059     }
69060   }
69061
69062   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69063   return jresult;
69064 }
69065
69066
69067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69068   void * jresult ;
69069   Dali::Toolkit::Alignment *arg1 = 0 ;
69070   Dali::Toolkit::Alignment *result = 0 ;
69071
69072   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69073   if (!arg1) {
69074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69075     return 0;
69076   }
69077   {
69078     try {
69079       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69080     } catch (std::out_of_range& e) {
69081       {
69082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69083       };
69084     } catch (std::exception& e) {
69085       {
69086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69087       };
69088     } catch (Dali::DaliException e) {
69089       {
69090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69091       };
69092     } catch (...) {
69093       {
69094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69095       };
69096     }
69097   }
69098
69099   jresult = (void *)result;
69100   return jresult;
69101 }
69102
69103
69104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69105   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69106
69107   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69108   {
69109     try {
69110       delete arg1;
69111     } catch (std::out_of_range& e) {
69112       {
69113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69114       };
69115     } catch (std::exception& e) {
69116       {
69117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69118       };
69119     } catch (Dali::DaliException e) {
69120       {
69121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69122       };
69123     } catch (...) {
69124       {
69125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69126       };
69127     }
69128   }
69129
69130 }
69131
69132
69133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69134   void * jresult ;
69135   Dali::BaseHandle arg1 ;
69136   Dali::BaseHandle *argp1 ;
69137   Dali::Toolkit::Alignment result;
69138
69139   argp1 = (Dali::BaseHandle *)jarg1;
69140   if (!argp1) {
69141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69142     return 0;
69143   }
69144   arg1 = *argp1;
69145   {
69146     try {
69147       result = Dali::Toolkit::Alignment::DownCast(arg1);
69148     } catch (std::out_of_range& e) {
69149       {
69150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69151       };
69152     } catch (std::exception& e) {
69153       {
69154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69155       };
69156     } catch (Dali::DaliException e) {
69157       {
69158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69159       };
69160     } catch (...) {
69161       {
69162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69163       };
69164     }
69165   }
69166
69167   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69168   return jresult;
69169 }
69170
69171
69172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69173   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69174   Dali::Toolkit::Alignment::Type arg2 ;
69175
69176   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69177   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69178   {
69179     try {
69180       (arg1)->SetAlignmentType(arg2);
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69188       };
69189     } catch (Dali::DaliException e) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69192       };
69193     } catch (...) {
69194       {
69195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69196       };
69197     }
69198   }
69199
69200 }
69201
69202
69203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69204   int jresult ;
69205   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69206   Dali::Toolkit::Alignment::Type result;
69207
69208   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69209   {
69210     try {
69211       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69212     } catch (std::out_of_range& e) {
69213       {
69214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69215       };
69216     } catch (std::exception& e) {
69217       {
69218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69219       };
69220     } catch (Dali::DaliException e) {
69221       {
69222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69223       };
69224     } catch (...) {
69225       {
69226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69227       };
69228     }
69229   }
69230
69231   jresult = (int)result;
69232   return jresult;
69233 }
69234
69235
69236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69237   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69238   Dali::Toolkit::Alignment::Scaling arg2 ;
69239
69240   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69241   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69242   {
69243     try {
69244       (arg1)->SetScaling(arg2);
69245     } catch (std::out_of_range& e) {
69246       {
69247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69248       };
69249     } catch (std::exception& e) {
69250       {
69251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69252       };
69253     } catch (Dali::DaliException e) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69256       };
69257     } catch (...) {
69258       {
69259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69260       };
69261     }
69262   }
69263
69264 }
69265
69266
69267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69268   int jresult ;
69269   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69270   Dali::Toolkit::Alignment::Scaling result;
69271
69272   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69273   {
69274     try {
69275       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69276     } catch (std::out_of_range& e) {
69277       {
69278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69279       };
69280     } catch (std::exception& e) {
69281       {
69282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69283       };
69284     } catch (Dali::DaliException e) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69287       };
69288     } catch (...) {
69289       {
69290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69291       };
69292     }
69293   }
69294
69295   jresult = (int)result;
69296   return jresult;
69297 }
69298
69299
69300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69301   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69302   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69303
69304   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69305   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69306   if (!arg2) {
69307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69308     return ;
69309   }
69310   {
69311     try {
69312       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69313     } catch (std::out_of_range& e) {
69314       {
69315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69316       };
69317     } catch (std::exception& e) {
69318       {
69319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69320       };
69321     } catch (Dali::DaliException e) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69324       };
69325     } catch (...) {
69326       {
69327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69328       };
69329     }
69330   }
69331
69332 }
69333
69334
69335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69336   void * jresult ;
69337   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69338   Dali::Toolkit::Alignment::Padding *result = 0 ;
69339
69340   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69341   {
69342     try {
69343       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69344     } catch (std::out_of_range& e) {
69345       {
69346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69347       };
69348     } catch (std::exception& e) {
69349       {
69350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69351       };
69352     } catch (Dali::DaliException e) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69355       };
69356     } catch (...) {
69357       {
69358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69359       };
69360     }
69361   }
69362
69363   jresult = (void *)result;
69364   return jresult;
69365 }
69366
69367
69368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69369   void * jresult ;
69370   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69371   Dali::Toolkit::Alignment *arg2 = 0 ;
69372   Dali::Toolkit::Alignment *result = 0 ;
69373
69374   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69375   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69376   if (!arg2) {
69377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69378     return 0;
69379   }
69380   {
69381     try {
69382       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69383     } catch (std::out_of_range& e) {
69384       {
69385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69386       };
69387     } catch (std::exception& e) {
69388       {
69389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69390       };
69391     } catch (Dali::DaliException e) {
69392       {
69393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69394       };
69395     } catch (...) {
69396       {
69397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69398       };
69399     }
69400   }
69401
69402   jresult = (void *)result;
69403   return jresult;
69404 }
69405
69406
69407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69408   int jresult ;
69409   int result;
69410
69411   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69412   jresult = (int)result;
69413   return jresult;
69414 }
69415
69416
69417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69418   int jresult ;
69419   int result;
69420
69421   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69422   jresult = (int)result;
69423   return jresult;
69424 }
69425
69426
69427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69428   int jresult ;
69429   int result;
69430
69431   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69432   jresult = (int)result;
69433   return jresult;
69434 }
69435
69436
69437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69438   int jresult ;
69439   int result;
69440
69441   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69442   jresult = (int)result;
69443   return jresult;
69444 }
69445
69446
69447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69448   int jresult ;
69449   int result;
69450
69451   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69452   jresult = (int)result;
69453   return jresult;
69454 }
69455
69456
69457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69458   int jresult ;
69459   int result;
69460
69461   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69462   jresult = (int)result;
69463   return jresult;
69464 }
69465
69466
69467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69468   int jresult ;
69469   int result;
69470
69471   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69472   jresult = (int)result;
69473   return jresult;
69474 }
69475
69476
69477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69478   int jresult ;
69479   int result;
69480
69481   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69482   jresult = (int)result;
69483   return jresult;
69484 }
69485
69486
69487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69488   int jresult ;
69489   int result;
69490
69491   result = (int)Dali::Toolkit::Button::Property::LABEL;
69492   jresult = (int)result;
69493   return jresult;
69494 }
69495
69496
69497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69498   int jresult ;
69499   int result;
69500
69501   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69502   jresult = (int)result;
69503   return jresult;
69504 }
69505
69506
69507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69508   void * jresult ;
69509   Dali::Toolkit::Button::Property *result = 0 ;
69510
69511   {
69512     try {
69513       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69514     } catch (std::out_of_range& e) {
69515       {
69516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69517       };
69518     } catch (std::exception& e) {
69519       {
69520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69521       };
69522     } catch (Dali::DaliException e) {
69523       {
69524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69525       };
69526     } catch (...) {
69527       {
69528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69529       };
69530     }
69531   }
69532
69533   jresult = (void *)result;
69534   return jresult;
69535 }
69536
69537
69538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69539   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69540
69541   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69542   {
69543     try {
69544       delete arg1;
69545     } catch (std::out_of_range& e) {
69546       {
69547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69548       };
69549     } catch (std::exception& e) {
69550       {
69551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69552       };
69553     } catch (Dali::DaliException e) {
69554       {
69555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69556       };
69557     } catch (...) {
69558       {
69559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69560       };
69561     }
69562   }
69563
69564 }
69565
69566
69567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69568   void * jresult ;
69569   Dali::Toolkit::Button *result = 0 ;
69570
69571   {
69572     try {
69573       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69574     } catch (std::out_of_range& e) {
69575       {
69576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69577       };
69578     } catch (std::exception& e) {
69579       {
69580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69581       };
69582     } catch (Dali::DaliException e) {
69583       {
69584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69585       };
69586     } catch (...) {
69587       {
69588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69589       };
69590     }
69591   }
69592
69593   jresult = (void *)result;
69594   return jresult;
69595 }
69596
69597
69598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69599   void * jresult ;
69600   Dali::Toolkit::Button *arg1 = 0 ;
69601   Dali::Toolkit::Button *result = 0 ;
69602
69603   arg1 = (Dali::Toolkit::Button *)jarg1;
69604   if (!arg1) {
69605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69606     return 0;
69607   }
69608   {
69609     try {
69610       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69611     } catch (std::out_of_range& e) {
69612       {
69613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69614       };
69615     } catch (std::exception& e) {
69616       {
69617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69618       };
69619     } catch (Dali::DaliException e) {
69620       {
69621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69622       };
69623     } catch (...) {
69624       {
69625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69626       };
69627     }
69628   }
69629
69630   jresult = (void *)result;
69631   return jresult;
69632 }
69633
69634
69635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69636   void * jresult ;
69637   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69638   Dali::Toolkit::Button *arg2 = 0 ;
69639   Dali::Toolkit::Button *result = 0 ;
69640
69641   arg1 = (Dali::Toolkit::Button *)jarg1;
69642   arg2 = (Dali::Toolkit::Button *)jarg2;
69643   if (!arg2) {
69644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69645     return 0;
69646   }
69647   {
69648     try {
69649       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69650     } catch (std::out_of_range& e) {
69651       {
69652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69653       };
69654     } catch (std::exception& e) {
69655       {
69656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69657       };
69658     } catch (Dali::DaliException e) {
69659       {
69660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69661       };
69662     } catch (...) {
69663       {
69664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69665       };
69666     }
69667   }
69668
69669   jresult = (void *)result;
69670   return jresult;
69671 }
69672
69673
69674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69675   void * jresult ;
69676   Dali::BaseHandle arg1 ;
69677   Dali::BaseHandle *argp1 ;
69678   Dali::Toolkit::Button result;
69679
69680   argp1 = (Dali::BaseHandle *)jarg1;
69681   if (!argp1) {
69682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69683     return 0;
69684   }
69685   arg1 = *argp1;
69686   {
69687     try {
69688       result = Dali::Toolkit::Button::DownCast(arg1);
69689     } catch (std::out_of_range& e) {
69690       {
69691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69692       };
69693     } catch (std::exception& e) {
69694       {
69695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69696       };
69697     } catch (Dali::DaliException e) {
69698       {
69699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69700       };
69701     } catch (...) {
69702       {
69703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69704       };
69705     }
69706   }
69707
69708   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69709   return jresult;
69710 }
69711
69712
69713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69714   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69715
69716   arg1 = (Dali::Toolkit::Button *)jarg1;
69717   {
69718     try {
69719       delete arg1;
69720     } catch (std::out_of_range& e) {
69721       {
69722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69723       };
69724     } catch (std::exception& e) {
69725       {
69726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69727       };
69728     } catch (Dali::DaliException e) {
69729       {
69730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69731       };
69732     } catch (...) {
69733       {
69734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69735       };
69736     }
69737   }
69738
69739 }
69740
69741
69742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69743   unsigned int jresult ;
69744   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69745   bool result;
69746
69747   arg1 = (Dali::Toolkit::Button *)jarg1;
69748   {
69749     try {
69750       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69751     } catch (std::out_of_range& e) {
69752       {
69753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69754       };
69755     } catch (std::exception& e) {
69756       {
69757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69758       };
69759     } catch (Dali::DaliException e) {
69760       {
69761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69762       };
69763     } catch (...) {
69764       {
69765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69766       };
69767     }
69768   }
69769
69770   jresult = result;
69771   return jresult;
69772 }
69773
69774
69775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69776   unsigned int jresult ;
69777   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69778   bool result;
69779
69780   arg1 = (Dali::Toolkit::Button *)jarg1;
69781   {
69782     try {
69783       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69784     } catch (std::out_of_range& e) {
69785       {
69786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69787       };
69788     } catch (std::exception& e) {
69789       {
69790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69791       };
69792     } catch (Dali::DaliException e) {
69793       {
69794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69795       };
69796     } catch (...) {
69797       {
69798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69799       };
69800     }
69801   }
69802
69803   jresult = result;
69804   return jresult;
69805 }
69806
69807
69808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69809   float jresult ;
69810   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69811   float result;
69812
69813   arg1 = (Dali::Toolkit::Button *)jarg1;
69814   {
69815     try {
69816       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69817     } catch (std::out_of_range& e) {
69818       {
69819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69820       };
69821     } catch (std::exception& e) {
69822       {
69823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69824       };
69825     } catch (Dali::DaliException e) {
69826       {
69827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69828       };
69829     } catch (...) {
69830       {
69831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69832       };
69833     }
69834   }
69835
69836   jresult = result;
69837   return jresult;
69838 }
69839
69840
69841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69842   float jresult ;
69843   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69844   float result;
69845
69846   arg1 = (Dali::Toolkit::Button *)jarg1;
69847   {
69848     try {
69849       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69850     } catch (std::out_of_range& e) {
69851       {
69852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69853       };
69854     } catch (std::exception& e) {
69855       {
69856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69857       };
69858     } catch (Dali::DaliException e) {
69859       {
69860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69861       };
69862     } catch (...) {
69863       {
69864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69865       };
69866     }
69867   }
69868
69869   jresult = result;
69870   return jresult;
69871 }
69872
69873
69874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69875   unsigned int jresult ;
69876   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69877   bool result;
69878
69879   arg1 = (Dali::Toolkit::Button *)jarg1;
69880   {
69881     try {
69882       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69883     } catch (std::out_of_range& e) {
69884       {
69885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69886       };
69887     } catch (std::exception& e) {
69888       {
69889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69890       };
69891     } catch (Dali::DaliException e) {
69892       {
69893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69894       };
69895     } catch (...) {
69896       {
69897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69898       };
69899     }
69900   }
69901
69902   jresult = result;
69903   return jresult;
69904 }
69905
69906
69907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69908   unsigned int jresult ;
69909   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69910   bool result;
69911
69912   arg1 = (Dali::Toolkit::Button *)jarg1;
69913   {
69914     try {
69915       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69916     } catch (std::out_of_range& e) {
69917       {
69918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69919       };
69920     } catch (std::exception& e) {
69921       {
69922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69923       };
69924     } catch (Dali::DaliException e) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69927       };
69928     } catch (...) {
69929       {
69930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69931       };
69932     }
69933   }
69934
69935   jresult = result;
69936   return jresult;
69937 }
69938
69939
69940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69941   float jresult ;
69942   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69943   float result;
69944
69945   arg1 = (Dali::Toolkit::Button *)jarg1;
69946   {
69947     try {
69948       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69949     } catch (std::out_of_range& e) {
69950       {
69951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69952       };
69953     } catch (std::exception& e) {
69954       {
69955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69956       };
69957     } catch (Dali::DaliException e) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69960       };
69961     } catch (...) {
69962       {
69963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69964       };
69965     }
69966   }
69967
69968   jresult = result;
69969   return jresult;
69970 }
69971
69972
69973 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69974   char * jresult ;
69975   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69976   std::string result;
69977
69978   arg1 = (Dali::Toolkit::Button *)jarg1;
69979   {
69980     try {
69981       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69982     } catch (std::out_of_range& e) {
69983       {
69984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69985       };
69986     } catch (std::exception& e) {
69987       {
69988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69989       };
69990     } catch (Dali::DaliException e) {
69991       {
69992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69993       };
69994     } catch (...) {
69995       {
69996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69997       };
69998     }
69999   }
70000
70001   jresult = SWIG_csharp_string_callback((&result)->c_str());
70002   return jresult;
70003 }
70004
70005
70006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70007   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70008   Dali::Actor arg2 ;
70009   Dali::Actor *argp2 ;
70010
70011   arg1 = (Dali::Toolkit::Button *)jarg1;
70012   argp2 = (Dali::Actor *)jarg2;
70013   if (!argp2) {
70014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70015     return ;
70016   }
70017   arg2 = *argp2;
70018   {
70019     try {
70020       (arg1)->SetLabel(arg2);
70021     } catch (std::out_of_range& e) {
70022       {
70023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70024       };
70025     } catch (std::exception& e) {
70026       {
70027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70028       };
70029     } catch (Dali::DaliException e) {
70030       {
70031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70032       };
70033     } catch (...) {
70034       {
70035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70036       };
70037     }
70038   }
70039
70040 }
70041
70042
70043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70044   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70045   Dali::Image arg2 ;
70046   Dali::Image *argp2 ;
70047
70048   arg1 = (Dali::Toolkit::Button *)jarg1;
70049   argp2 = (Dali::Image *)jarg2;
70050   if (!argp2) {
70051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70052     return ;
70053   }
70054   arg2 = *argp2;
70055   {
70056     try {
70057       (arg1)->SetButtonImage(arg2);
70058     } catch (std::out_of_range& e) {
70059       {
70060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70061       };
70062     } catch (std::exception& e) {
70063       {
70064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70065       };
70066     } catch (Dali::DaliException e) {
70067       {
70068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70069       };
70070     } catch (...) {
70071       {
70072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70073       };
70074     }
70075   }
70076
70077 }
70078
70079
70080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70081   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70082   Dali::Image arg2 ;
70083   Dali::Image *argp2 ;
70084
70085   arg1 = (Dali::Toolkit::Button *)jarg1;
70086   argp2 = (Dali::Image *)jarg2;
70087   if (!argp2) {
70088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70089     return ;
70090   }
70091   arg2 = *argp2;
70092   {
70093     try {
70094       (arg1)->SetSelectedImage(arg2);
70095     } catch (std::out_of_range& e) {
70096       {
70097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70098       };
70099     } catch (std::exception& e) {
70100       {
70101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70102       };
70103     } catch (Dali::DaliException e) {
70104       {
70105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70106       };
70107     } catch (...) {
70108       {
70109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70110       };
70111     }
70112   }
70113
70114 }
70115
70116
70117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70118   void * jresult ;
70119   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70120   Dali::Actor result;
70121
70122   arg1 = (Dali::Toolkit::Button *)jarg1;
70123   {
70124     try {
70125       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70126     } catch (std::out_of_range& e) {
70127       {
70128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70129       };
70130     } catch (std::exception& e) {
70131       {
70132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70133       };
70134     } catch (Dali::DaliException e) {
70135       {
70136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70137       };
70138     } catch (...) {
70139       {
70140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70141       };
70142     }
70143   }
70144
70145   jresult = new Dali::Actor((const Dali::Actor &)result);
70146   return jresult;
70147 }
70148
70149
70150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70151   void * jresult ;
70152   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70153   Dali::Actor result;
70154
70155   arg1 = (Dali::Toolkit::Button *)jarg1;
70156   {
70157     try {
70158       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70159     } catch (std::out_of_range& e) {
70160       {
70161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70162       };
70163     } catch (std::exception& e) {
70164       {
70165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70166       };
70167     } catch (Dali::DaliException e) {
70168       {
70169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70170       };
70171     } catch (...) {
70172       {
70173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70174       };
70175     }
70176   }
70177
70178   jresult = new Dali::Actor((const Dali::Actor &)result);
70179   return jresult;
70180 }
70181
70182
70183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70184   void * jresult ;
70185   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70186   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70187
70188   arg1 = (Dali::Toolkit::Button *)jarg1;
70189   {
70190     try {
70191       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70192     } catch (std::out_of_range& e) {
70193       {
70194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70195       };
70196     } catch (std::exception& e) {
70197       {
70198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70199       };
70200     } catch (Dali::DaliException e) {
70201       {
70202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70203       };
70204     } catch (...) {
70205       {
70206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70207       };
70208     }
70209   }
70210
70211   jresult = (void *)result;
70212   return jresult;
70213 }
70214
70215
70216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70217   void * jresult ;
70218   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70219   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70220
70221   arg1 = (Dali::Toolkit::Button *)jarg1;
70222   {
70223     try {
70224       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70225     } catch (std::out_of_range& e) {
70226       {
70227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70228       };
70229     } catch (std::exception& e) {
70230       {
70231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70232       };
70233     } catch (Dali::DaliException e) {
70234       {
70235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70236       };
70237     } catch (...) {
70238       {
70239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70240       };
70241     }
70242   }
70243
70244   jresult = (void *)result;
70245   return jresult;
70246 }
70247
70248
70249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70250   void * jresult ;
70251   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70252   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70253
70254   arg1 = (Dali::Toolkit::Button *)jarg1;
70255   {
70256     try {
70257       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70258     } catch (std::out_of_range& e) {
70259       {
70260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70261       };
70262     } catch (std::exception& e) {
70263       {
70264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70265       };
70266     } catch (Dali::DaliException e) {
70267       {
70268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70269       };
70270     } catch (...) {
70271       {
70272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70273       };
70274     }
70275   }
70276
70277   jresult = (void *)result;
70278   return jresult;
70279 }
70280
70281
70282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70283   void * jresult ;
70284   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70285   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70286
70287   arg1 = (Dali::Toolkit::Button *)jarg1;
70288   {
70289     try {
70290       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70291     } catch (std::out_of_range& e) {
70292       {
70293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70294       };
70295     } catch (std::exception& e) {
70296       {
70297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70298       };
70299     } catch (Dali::DaliException e) {
70300       {
70301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70302       };
70303     } catch (...) {
70304       {
70305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70306       };
70307     }
70308   }
70309
70310   jresult = (void *)result;
70311   return jresult;
70312 }
70313
70314
70315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70316   void * jresult ;
70317   Dali::Toolkit::CheckBoxButton *result = 0 ;
70318
70319   {
70320     try {
70321       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70322     } catch (std::out_of_range& e) {
70323       {
70324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70325       };
70326     } catch (std::exception& e) {
70327       {
70328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70329       };
70330     } catch (Dali::DaliException e) {
70331       {
70332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70333       };
70334     } catch (...) {
70335       {
70336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70337       };
70338     }
70339   }
70340
70341   jresult = (void *)result;
70342   return jresult;
70343 }
70344
70345
70346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70347   void * jresult ;
70348   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70349   Dali::Toolkit::CheckBoxButton *result = 0 ;
70350
70351   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70352   if (!arg1) {
70353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70354     return 0;
70355   }
70356   {
70357     try {
70358       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70359     } catch (std::out_of_range& e) {
70360       {
70361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70362       };
70363     } catch (std::exception& e) {
70364       {
70365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70366       };
70367     } catch (Dali::DaliException e) {
70368       {
70369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70370       };
70371     } catch (...) {
70372       {
70373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70374       };
70375     }
70376   }
70377
70378   jresult = (void *)result;
70379   return jresult;
70380 }
70381
70382
70383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70384   void * jresult ;
70385   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70386   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70387   Dali::Toolkit::CheckBoxButton *result = 0 ;
70388
70389   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70390   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70391   if (!arg2) {
70392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70393     return 0;
70394   }
70395   {
70396     try {
70397       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70398     } catch (std::out_of_range& e) {
70399       {
70400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70401       };
70402     } catch (std::exception& e) {
70403       {
70404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70405       };
70406     } catch (Dali::DaliException e) {
70407       {
70408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70409       };
70410     } catch (...) {
70411       {
70412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70413       };
70414     }
70415   }
70416
70417   jresult = (void *)result;
70418   return jresult;
70419 }
70420
70421
70422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70423   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70424
70425   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70426   {
70427     try {
70428       delete arg1;
70429     } catch (std::out_of_range& e) {
70430       {
70431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70432       };
70433     } catch (std::exception& e) {
70434       {
70435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70436       };
70437     } catch (Dali::DaliException e) {
70438       {
70439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70440       };
70441     } catch (...) {
70442       {
70443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70444       };
70445     }
70446   }
70447
70448 }
70449
70450
70451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70452   void * jresult ;
70453   Dali::Toolkit::CheckBoxButton result;
70454
70455   {
70456     try {
70457       result = Dali::Toolkit::CheckBoxButton::New();
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70465       };
70466     } catch (Dali::DaliException e) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70473       };
70474     }
70475   }
70476
70477   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70478   return jresult;
70479 }
70480
70481
70482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70483   void * jresult ;
70484   Dali::BaseHandle arg1 ;
70485   Dali::BaseHandle *argp1 ;
70486   Dali::Toolkit::CheckBoxButton result;
70487
70488   argp1 = (Dali::BaseHandle *)jarg1;
70489   if (!argp1) {
70490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70491     return 0;
70492   }
70493   arg1 = *argp1;
70494   {
70495     try {
70496       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70497     } catch (std::out_of_range& e) {
70498       {
70499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70500       };
70501     } catch (std::exception& e) {
70502       {
70503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70504       };
70505     } catch (Dali::DaliException e) {
70506       {
70507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70508       };
70509     } catch (...) {
70510       {
70511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70512       };
70513     }
70514   }
70515
70516   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70517   return jresult;
70518 }
70519
70520
70521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70522   int jresult ;
70523   int result;
70524
70525   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70526   jresult = (int)result;
70527   return jresult;
70528 }
70529
70530
70531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70532   int jresult ;
70533   int result;
70534
70535   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70536   jresult = (int)result;
70537   return jresult;
70538 }
70539
70540
70541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70542   int jresult ;
70543   int result;
70544
70545   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70546   jresult = (int)result;
70547   return jresult;
70548 }
70549
70550
70551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70552   int jresult ;
70553   int result;
70554
70555   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70556   jresult = (int)result;
70557   return jresult;
70558 }
70559
70560
70561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70562   int jresult ;
70563   int result;
70564
70565   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70566   jresult = (int)result;
70567   return jresult;
70568 }
70569
70570
70571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70572   void * jresult ;
70573   Dali::Toolkit::PushButton::Property *result = 0 ;
70574
70575   {
70576     try {
70577       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70578     } catch (std::out_of_range& e) {
70579       {
70580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70581       };
70582     } catch (std::exception& e) {
70583       {
70584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70585       };
70586     } catch (Dali::DaliException e) {
70587       {
70588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70589       };
70590     } catch (...) {
70591       {
70592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70593       };
70594     }
70595   }
70596
70597   jresult = (void *)result;
70598   return jresult;
70599 }
70600
70601
70602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70603   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70604
70605   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70606   {
70607     try {
70608       delete arg1;
70609     } catch (std::out_of_range& e) {
70610       {
70611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70612       };
70613     } catch (std::exception& e) {
70614       {
70615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70616       };
70617     } catch (Dali::DaliException e) {
70618       {
70619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70620       };
70621     } catch (...) {
70622       {
70623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70624       };
70625     }
70626   }
70627
70628 }
70629
70630
70631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70632   void * jresult ;
70633   Dali::Toolkit::PushButton *result = 0 ;
70634
70635   {
70636     try {
70637       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70638     } catch (std::out_of_range& e) {
70639       {
70640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70641       };
70642     } catch (std::exception& e) {
70643       {
70644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70645       };
70646     } catch (Dali::DaliException e) {
70647       {
70648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70649       };
70650     } catch (...) {
70651       {
70652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70653       };
70654     }
70655   }
70656
70657   jresult = (void *)result;
70658   return jresult;
70659 }
70660
70661
70662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70663   void * jresult ;
70664   Dali::Toolkit::PushButton *arg1 = 0 ;
70665   Dali::Toolkit::PushButton *result = 0 ;
70666
70667   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70668   if (!arg1) {
70669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70670     return 0;
70671   }
70672   {
70673     try {
70674       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70675     } catch (std::out_of_range& e) {
70676       {
70677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70678       };
70679     } catch (std::exception& e) {
70680       {
70681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70682       };
70683     } catch (Dali::DaliException e) {
70684       {
70685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70686       };
70687     } catch (...) {
70688       {
70689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70690       };
70691     }
70692   }
70693
70694   jresult = (void *)result;
70695   return jresult;
70696 }
70697
70698
70699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70700   void * jresult ;
70701   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70702   Dali::Toolkit::PushButton *arg2 = 0 ;
70703   Dali::Toolkit::PushButton *result = 0 ;
70704
70705   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70706   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70707   if (!arg2) {
70708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70709     return 0;
70710   }
70711   {
70712     try {
70713       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70714     } catch (std::out_of_range& e) {
70715       {
70716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70717       };
70718     } catch (std::exception& e) {
70719       {
70720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70721       };
70722     } catch (Dali::DaliException e) {
70723       {
70724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70725       };
70726     } catch (...) {
70727       {
70728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70729       };
70730     }
70731   }
70732
70733   jresult = (void *)result;
70734   return jresult;
70735 }
70736
70737
70738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70739   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70740
70741   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70742   {
70743     try {
70744       delete arg1;
70745     } catch (std::out_of_range& e) {
70746       {
70747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70748       };
70749     } catch (std::exception& e) {
70750       {
70751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70752       };
70753     } catch (Dali::DaliException e) {
70754       {
70755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70756       };
70757     } catch (...) {
70758       {
70759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70760       };
70761     }
70762   }
70763
70764 }
70765
70766
70767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70768   void * jresult ;
70769   Dali::Toolkit::PushButton result;
70770
70771   {
70772     try {
70773       result = Dali::Toolkit::PushButton::New();
70774     } catch (std::out_of_range& e) {
70775       {
70776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70777       };
70778     } catch (std::exception& e) {
70779       {
70780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70781       };
70782     } catch (Dali::DaliException e) {
70783       {
70784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70785       };
70786     } catch (...) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70789       };
70790     }
70791   }
70792
70793   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70794   return jresult;
70795 }
70796
70797
70798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70799   void * jresult ;
70800   Dali::BaseHandle arg1 ;
70801   Dali::BaseHandle *argp1 ;
70802   Dali::Toolkit::PushButton result;
70803
70804   argp1 = (Dali::BaseHandle *)jarg1;
70805   if (!argp1) {
70806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70807     return 0;
70808   }
70809   arg1 = *argp1;
70810   {
70811     try {
70812       result = Dali::Toolkit::PushButton::DownCast(arg1);
70813     } catch (std::out_of_range& e) {
70814       {
70815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70816       };
70817     } catch (std::exception& e) {
70818       {
70819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70820       };
70821     } catch (Dali::DaliException e) {
70822       {
70823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70824       };
70825     } catch (...) {
70826       {
70827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70828       };
70829     }
70830   }
70831
70832   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70833   return jresult;
70834 }
70835
70836
70837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70838   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70839   Dali::Image arg2 ;
70840   Dali::Image *argp2 ;
70841
70842   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70843   argp2 = (Dali::Image *)jarg2;
70844   if (!argp2) {
70845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70846     return ;
70847   }
70848   arg2 = *argp2;
70849   {
70850     try {
70851       (arg1)->SetButtonImage(arg2);
70852     } catch (std::out_of_range& e) {
70853       {
70854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70855       };
70856     } catch (std::exception& e) {
70857       {
70858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70859       };
70860     } catch (Dali::DaliException e) {
70861       {
70862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70863       };
70864     } catch (...) {
70865       {
70866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70867       };
70868     }
70869   }
70870
70871 }
70872
70873
70874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70875   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70876   Dali::Actor arg2 ;
70877   Dali::Actor *argp2 ;
70878
70879   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70880   argp2 = (Dali::Actor *)jarg2;
70881   if (!argp2) {
70882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70883     return ;
70884   }
70885   arg2 = *argp2;
70886   {
70887     try {
70888       (arg1)->SetButtonImage(arg2);
70889     } catch (std::out_of_range& e) {
70890       {
70891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70892       };
70893     } catch (std::exception& e) {
70894       {
70895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70896       };
70897     } catch (Dali::DaliException e) {
70898       {
70899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70900       };
70901     } catch (...) {
70902       {
70903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70904       };
70905     }
70906   }
70907
70908 }
70909
70910
70911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70912   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70913   Dali::Actor arg2 ;
70914   Dali::Actor *argp2 ;
70915
70916   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70917   argp2 = (Dali::Actor *)jarg2;
70918   if (!argp2) {
70919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70920     return ;
70921   }
70922   arg2 = *argp2;
70923   {
70924     try {
70925       (arg1)->SetBackgroundImage(arg2);
70926     } catch (std::out_of_range& e) {
70927       {
70928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70929       };
70930     } catch (std::exception& e) {
70931       {
70932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70933       };
70934     } catch (Dali::DaliException e) {
70935       {
70936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70937       };
70938     } catch (...) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70941       };
70942     }
70943   }
70944
70945 }
70946
70947
70948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70949   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70950   Dali::Image arg2 ;
70951   Dali::Image *argp2 ;
70952
70953   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70954   argp2 = (Dali::Image *)jarg2;
70955   if (!argp2) {
70956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70957     return ;
70958   }
70959   arg2 = *argp2;
70960   {
70961     try {
70962       (arg1)->SetSelectedImage(arg2);
70963     } catch (std::out_of_range& e) {
70964       {
70965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70966       };
70967     } catch (std::exception& e) {
70968       {
70969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70970       };
70971     } catch (Dali::DaliException e) {
70972       {
70973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70974       };
70975     } catch (...) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70978       };
70979     }
70980   }
70981
70982 }
70983
70984
70985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70986   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70987   Dali::Actor arg2 ;
70988   Dali::Actor *argp2 ;
70989
70990   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70991   argp2 = (Dali::Actor *)jarg2;
70992   if (!argp2) {
70993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70994     return ;
70995   }
70996   arg2 = *argp2;
70997   {
70998     try {
70999       (arg1)->SetSelectedImage(arg2);
71000     } catch (std::out_of_range& e) {
71001       {
71002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71003       };
71004     } catch (std::exception& e) {
71005       {
71006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71007       };
71008     } catch (Dali::DaliException e) {
71009       {
71010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71011       };
71012     } catch (...) {
71013       {
71014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71015       };
71016     }
71017   }
71018
71019 }
71020
71021
71022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71023   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71024   Dali::Actor arg2 ;
71025   Dali::Actor *argp2 ;
71026
71027   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71028   argp2 = (Dali::Actor *)jarg2;
71029   if (!argp2) {
71030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71031     return ;
71032   }
71033   arg2 = *argp2;
71034   {
71035     try {
71036       (arg1)->SetSelectedBackgroundImage(arg2);
71037     } catch (std::out_of_range& e) {
71038       {
71039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71040       };
71041     } catch (std::exception& e) {
71042       {
71043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71044       };
71045     } catch (Dali::DaliException e) {
71046       {
71047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71048       };
71049     } catch (...) {
71050       {
71051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71052       };
71053     }
71054   }
71055
71056 }
71057
71058
71059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71060   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71061   Dali::Actor arg2 ;
71062   Dali::Actor *argp2 ;
71063
71064   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71065   argp2 = (Dali::Actor *)jarg2;
71066   if (!argp2) {
71067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71068     return ;
71069   }
71070   arg2 = *argp2;
71071   {
71072     try {
71073       (arg1)->SetDisabledBackgroundImage(arg2);
71074     } catch (std::out_of_range& e) {
71075       {
71076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71077       };
71078     } catch (std::exception& e) {
71079       {
71080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71081       };
71082     } catch (Dali::DaliException e) {
71083       {
71084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71085       };
71086     } catch (...) {
71087       {
71088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71089       };
71090     }
71091   }
71092
71093 }
71094
71095
71096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71097   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71098   Dali::Actor arg2 ;
71099   Dali::Actor *argp2 ;
71100
71101   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71102   argp2 = (Dali::Actor *)jarg2;
71103   if (!argp2) {
71104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71105     return ;
71106   }
71107   arg2 = *argp2;
71108   {
71109     try {
71110       (arg1)->SetDisabledImage(arg2);
71111     } catch (std::out_of_range& e) {
71112       {
71113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71114       };
71115     } catch (std::exception& e) {
71116       {
71117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71118       };
71119     } catch (Dali::DaliException e) {
71120       {
71121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71122       };
71123     } catch (...) {
71124       {
71125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71126       };
71127     }
71128   }
71129
71130 }
71131
71132
71133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71134   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71135   Dali::Actor arg2 ;
71136   Dali::Actor *argp2 ;
71137
71138   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71139   argp2 = (Dali::Actor *)jarg2;
71140   if (!argp2) {
71141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71142     return ;
71143   }
71144   arg2 = *argp2;
71145   {
71146     try {
71147       (arg1)->SetDisabledSelectedImage(arg2);
71148     } catch (std::out_of_range& e) {
71149       {
71150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71151       };
71152     } catch (std::exception& e) {
71153       {
71154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71155       };
71156     } catch (Dali::DaliException e) {
71157       {
71158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71159       };
71160     } catch (...) {
71161       {
71162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71163       };
71164     }
71165   }
71166
71167 }
71168
71169
71170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71171   void * jresult ;
71172   Dali::Toolkit::RadioButton *result = 0 ;
71173
71174   {
71175     try {
71176       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71177     } catch (std::out_of_range& e) {
71178       {
71179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71180       };
71181     } catch (std::exception& e) {
71182       {
71183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71184       };
71185     } catch (Dali::DaliException e) {
71186       {
71187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71188       };
71189     } catch (...) {
71190       {
71191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71192       };
71193     }
71194   }
71195
71196   jresult = (void *)result;
71197   return jresult;
71198 }
71199
71200
71201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71202   void * jresult ;
71203   Dali::Toolkit::RadioButton *arg1 = 0 ;
71204   Dali::Toolkit::RadioButton *result = 0 ;
71205
71206   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71207   if (!arg1) {
71208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71209     return 0;
71210   }
71211   {
71212     try {
71213       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71214     } catch (std::out_of_range& e) {
71215       {
71216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71217       };
71218     } catch (std::exception& e) {
71219       {
71220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71221       };
71222     } catch (Dali::DaliException e) {
71223       {
71224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71225       };
71226     } catch (...) {
71227       {
71228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71229       };
71230     }
71231   }
71232
71233   jresult = (void *)result;
71234   return jresult;
71235 }
71236
71237
71238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71239   void * jresult ;
71240   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71241   Dali::Toolkit::RadioButton *arg2 = 0 ;
71242   Dali::Toolkit::RadioButton *result = 0 ;
71243
71244   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71245   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71246   if (!arg2) {
71247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71248     return 0;
71249   }
71250   {
71251     try {
71252       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71253     } catch (std::out_of_range& e) {
71254       {
71255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71256       };
71257     } catch (std::exception& e) {
71258       {
71259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71260       };
71261     } catch (Dali::DaliException e) {
71262       {
71263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71264       };
71265     } catch (...) {
71266       {
71267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71268       };
71269     }
71270   }
71271
71272   jresult = (void *)result;
71273   return jresult;
71274 }
71275
71276
71277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71278   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71279
71280   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71281   {
71282     try {
71283       delete arg1;
71284     } catch (std::out_of_range& e) {
71285       {
71286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71287       };
71288     } catch (std::exception& e) {
71289       {
71290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71291       };
71292     } catch (Dali::DaliException e) {
71293       {
71294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71295       };
71296     } catch (...) {
71297       {
71298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71299       };
71300     }
71301   }
71302
71303 }
71304
71305
71306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71307   void * jresult ;
71308   Dali::Toolkit::RadioButton result;
71309
71310   {
71311     try {
71312       result = Dali::Toolkit::RadioButton::New();
71313     } catch (std::out_of_range& e) {
71314       {
71315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71316       };
71317     } catch (std::exception& e) {
71318       {
71319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71320       };
71321     } catch (Dali::DaliException e) {
71322       {
71323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71324       };
71325     } catch (...) {
71326       {
71327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71328       };
71329     }
71330   }
71331
71332   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71333   return jresult;
71334 }
71335
71336
71337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71338   void * jresult ;
71339   std::string *arg1 = 0 ;
71340   Dali::Toolkit::RadioButton result;
71341
71342   if (!jarg1) {
71343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71344     return 0;
71345   }
71346   std::string arg1_str(jarg1);
71347   arg1 = &arg1_str;
71348   {
71349     try {
71350       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71351     } catch (std::out_of_range& e) {
71352       {
71353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71354       };
71355     } catch (std::exception& e) {
71356       {
71357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71358       };
71359     } catch (Dali::DaliException e) {
71360       {
71361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71362       };
71363     } catch (...) {
71364       {
71365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71366       };
71367     }
71368   }
71369
71370   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71371
71372   //argout typemap for const std::string&
71373
71374   return jresult;
71375 }
71376
71377
71378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71379   void * jresult ;
71380   Dali::BaseHandle arg1 ;
71381   Dali::BaseHandle *argp1 ;
71382   Dali::Toolkit::RadioButton result;
71383
71384   argp1 = (Dali::BaseHandle *)jarg1;
71385   if (!argp1) {
71386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71387     return 0;
71388   }
71389   arg1 = *argp1;
71390   {
71391     try {
71392       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71393     } catch (std::out_of_range& e) {
71394       {
71395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71396       };
71397     } catch (std::exception& e) {
71398       {
71399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71400       };
71401     } catch (Dali::DaliException e) {
71402       {
71403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71404       };
71405     } catch (...) {
71406       {
71407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71408       };
71409     }
71410   }
71411
71412   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71413   return jresult;
71414 }
71415
71416
71417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71418   int jresult ;
71419   int result;
71420
71421   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71422   jresult = (int)result;
71423   return jresult;
71424 }
71425
71426
71427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71428   int jresult ;
71429   int result;
71430
71431   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71432   jresult = (int)result;
71433   return jresult;
71434 }
71435
71436
71437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71438   int jresult ;
71439   int result;
71440
71441   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71442   jresult = (int)result;
71443   return jresult;
71444 }
71445
71446
71447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71448   int jresult ;
71449   int result;
71450
71451   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71452   jresult = (int)result;
71453   return jresult;
71454 }
71455
71456
71457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71458   int jresult ;
71459   int result;
71460
71461   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71462   jresult = (int)result;
71463   return jresult;
71464 }
71465
71466
71467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71468   int jresult ;
71469   int result;
71470
71471   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71472   jresult = (int)result;
71473   return jresult;
71474 }
71475
71476
71477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71478   void * jresult ;
71479   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71480
71481   {
71482     try {
71483       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71484     } catch (std::out_of_range& e) {
71485       {
71486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71487       };
71488     } catch (std::exception& e) {
71489       {
71490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71491       };
71492     } catch (Dali::DaliException e) {
71493       {
71494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71495       };
71496     } catch (...) {
71497       {
71498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71499       };
71500     }
71501   }
71502
71503   jresult = (void *)result;
71504   return jresult;
71505 }
71506
71507
71508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71509   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71510
71511   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71512   {
71513     try {
71514       delete arg1;
71515     } catch (std::out_of_range& e) {
71516       {
71517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71518       };
71519     } catch (std::exception& e) {
71520       {
71521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71522       };
71523     } catch (Dali::DaliException e) {
71524       {
71525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71526       };
71527     } catch (...) {
71528       {
71529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71530       };
71531     }
71532   }
71533
71534 }
71535
71536
71537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71538   int jresult ;
71539   int result;
71540
71541   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71542   jresult = (int)result;
71543   return jresult;
71544 }
71545
71546
71547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71548   int jresult ;
71549   int result;
71550
71551   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71552   jresult = (int)result;
71553   return jresult;
71554 }
71555
71556
71557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71558   int jresult ;
71559   int result;
71560
71561   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71562   jresult = (int)result;
71563   return jresult;
71564 }
71565
71566
71567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71568   void * jresult ;
71569   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71570
71571   {
71572     try {
71573       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71574     } catch (std::out_of_range& e) {
71575       {
71576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71577       };
71578     } catch (std::exception& e) {
71579       {
71580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71581       };
71582     } catch (Dali::DaliException e) {
71583       {
71584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71585       };
71586     } catch (...) {
71587       {
71588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71589       };
71590     }
71591   }
71592
71593   jresult = (void *)result;
71594   return jresult;
71595 }
71596
71597
71598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71599   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71600
71601   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71602   {
71603     try {
71604       delete arg1;
71605     } catch (std::out_of_range& e) {
71606       {
71607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71608       };
71609     } catch (std::exception& e) {
71610       {
71611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71612       };
71613     } catch (Dali::DaliException e) {
71614       {
71615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71616       };
71617     } catch (...) {
71618       {
71619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71620       };
71621     }
71622   }
71623
71624 }
71625
71626
71627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71628   void * jresult ;
71629   Dali::Toolkit::FlexContainer *result = 0 ;
71630
71631   {
71632     try {
71633       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71634     } catch (std::out_of_range& e) {
71635       {
71636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71637       };
71638     } catch (std::exception& e) {
71639       {
71640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71641       };
71642     } catch (Dali::DaliException e) {
71643       {
71644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71645       };
71646     } catch (...) {
71647       {
71648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71649       };
71650     }
71651   }
71652
71653   jresult = (void *)result;
71654   return jresult;
71655 }
71656
71657
71658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71659   void * jresult ;
71660   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71661   Dali::Toolkit::FlexContainer *result = 0 ;
71662
71663   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71664   if (!arg1) {
71665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71666     return 0;
71667   }
71668   {
71669     try {
71670       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71671     } catch (std::out_of_range& e) {
71672       {
71673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (std::exception& e) {
71676       {
71677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71678       };
71679     } catch (Dali::DaliException e) {
71680       {
71681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71682       };
71683     } catch (...) {
71684       {
71685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71686       };
71687     }
71688   }
71689
71690   jresult = (void *)result;
71691   return jresult;
71692 }
71693
71694
71695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71696   void * jresult ;
71697   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71698   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71699   Dali::Toolkit::FlexContainer *result = 0 ;
71700
71701   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71702   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71703   if (!arg2) {
71704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71705     return 0;
71706   }
71707   {
71708     try {
71709       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71710     } catch (std::out_of_range& e) {
71711       {
71712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71713       };
71714     } catch (std::exception& e) {
71715       {
71716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71717       };
71718     } catch (Dali::DaliException e) {
71719       {
71720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71721       };
71722     } catch (...) {
71723       {
71724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71725       };
71726     }
71727   }
71728
71729   jresult = (void *)result;
71730   return jresult;
71731 }
71732
71733
71734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71735   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71736
71737   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71738   {
71739     try {
71740       delete arg1;
71741     } catch (std::out_of_range& e) {
71742       {
71743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71744       };
71745     } catch (std::exception& e) {
71746       {
71747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71748       };
71749     } catch (Dali::DaliException e) {
71750       {
71751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71752       };
71753     } catch (...) {
71754       {
71755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71756       };
71757     }
71758   }
71759
71760 }
71761
71762
71763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71764   void * jresult ;
71765   Dali::Toolkit::FlexContainer result;
71766
71767   {
71768     try {
71769       result = Dali::Toolkit::FlexContainer::New();
71770     } catch (std::out_of_range& e) {
71771       {
71772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71773       };
71774     } catch (std::exception& e) {
71775       {
71776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71777       };
71778     } catch (Dali::DaliException e) {
71779       {
71780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71781       };
71782     } catch (...) {
71783       {
71784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71785       };
71786     }
71787   }
71788
71789   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71790   return jresult;
71791 }
71792
71793
71794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71795   void * jresult ;
71796   Dali::BaseHandle arg1 ;
71797   Dali::BaseHandle *argp1 ;
71798   Dali::Toolkit::FlexContainer result;
71799
71800   argp1 = (Dali::BaseHandle *)jarg1;
71801   if (!argp1) {
71802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71803     return 0;
71804   }
71805   arg1 = *argp1;
71806   {
71807     try {
71808       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71809     } catch (std::out_of_range& e) {
71810       {
71811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71812       };
71813     } catch (std::exception& e) {
71814       {
71815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71816       };
71817     } catch (Dali::DaliException e) {
71818       {
71819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71820       };
71821     } catch (...) {
71822       {
71823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71824       };
71825     }
71826   }
71827
71828   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71829   return jresult;
71830 }
71831
71832
71833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71834   int jresult ;
71835   int result;
71836
71837   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71838   jresult = (int)result;
71839   return jresult;
71840 }
71841
71842
71843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71844   int jresult ;
71845   int result;
71846
71847   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71848   jresult = (int)result;
71849   return jresult;
71850 }
71851
71852
71853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71854   int jresult ;
71855   int result;
71856
71857   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71858   jresult = (int)result;
71859   return jresult;
71860 }
71861
71862
71863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71864   int jresult ;
71865   int result;
71866
71867   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71868   jresult = (int)result;
71869   return jresult;
71870 }
71871
71872
71873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71874   void * jresult ;
71875   Dali::Toolkit::ImageView::Property *result = 0 ;
71876
71877   {
71878     try {
71879       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71880     } catch (std::out_of_range& e) {
71881       {
71882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71883       };
71884     } catch (std::exception& e) {
71885       {
71886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71887       };
71888     } catch (Dali::DaliException e) {
71889       {
71890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71891       };
71892     } catch (...) {
71893       {
71894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71895       };
71896     }
71897   }
71898
71899   jresult = (void *)result;
71900   return jresult;
71901 }
71902
71903
71904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71905   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71906
71907   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71908   {
71909     try {
71910       delete arg1;
71911     } catch (std::out_of_range& e) {
71912       {
71913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71914       };
71915     } catch (std::exception& e) {
71916       {
71917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71918       };
71919     } catch (Dali::DaliException e) {
71920       {
71921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71922       };
71923     } catch (...) {
71924       {
71925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71926       };
71927     }
71928   }
71929
71930 }
71931
71932
71933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71934   void * jresult ;
71935   Dali::Toolkit::ImageView *result = 0 ;
71936
71937   {
71938     try {
71939       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71940     } catch (std::out_of_range& e) {
71941       {
71942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71943       };
71944     } catch (std::exception& e) {
71945       {
71946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71947       };
71948     } catch (Dali::DaliException e) {
71949       {
71950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71951       };
71952     } catch (...) {
71953       {
71954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71955       };
71956     }
71957   }
71958
71959   jresult = (void *)result;
71960   return jresult;
71961 }
71962
71963
71964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71965   void * jresult ;
71966   Dali::Toolkit::ImageView result;
71967
71968   {
71969     try {
71970       result = Dali::Toolkit::ImageView::New();
71971     } catch (std::out_of_range& e) {
71972       {
71973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71974       };
71975     } catch (std::exception& e) {
71976       {
71977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71978       };
71979     } catch (Dali::DaliException e) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71982       };
71983     } catch (...) {
71984       {
71985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71986       };
71987     }
71988   }
71989
71990   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71991   return jresult;
71992 }
71993
71994
71995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71996   void * jresult ;
71997   Dali::Image arg1 ;
71998   Dali::Image *argp1 ;
71999   Dali::Toolkit::ImageView result;
72000
72001   argp1 = (Dali::Image *)jarg1;
72002   if (!argp1) {
72003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72004     return 0;
72005   }
72006   arg1 = *argp1;
72007   {
72008     try {
72009       result = Dali::Toolkit::ImageView::New(arg1);
72010     } catch (std::out_of_range& e) {
72011       {
72012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72013       };
72014     } catch (std::exception& e) {
72015       {
72016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72017       };
72018     } catch (Dali::DaliException e) {
72019       {
72020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72021       };
72022     } catch (...) {
72023       {
72024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72025       };
72026     }
72027   }
72028
72029   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72030   return jresult;
72031 }
72032
72033
72034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72035   void * jresult ;
72036   std::string *arg1 = 0 ;
72037   Dali::Toolkit::ImageView result;
72038
72039   if (!jarg1) {
72040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72041     return 0;
72042   }
72043   std::string arg1_str(jarg1);
72044   arg1 = &arg1_str;
72045   {
72046     try {
72047       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72048     } catch (std::out_of_range& e) {
72049       {
72050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72051       };
72052     } catch (std::exception& e) {
72053       {
72054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72055       };
72056     } catch (Dali::DaliException e) {
72057       {
72058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72059       };
72060     } catch (...) {
72061       {
72062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72063       };
72064     }
72065   }
72066
72067   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72068
72069   //argout typemap for const std::string&
72070
72071   return jresult;
72072 }
72073
72074
72075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72076   void * jresult ;
72077   std::string *arg1 = 0 ;
72078   Dali::ImageDimensions arg2 ;
72079   Dali::ImageDimensions *argp2 ;
72080   Dali::Toolkit::ImageView result;
72081
72082   if (!jarg1) {
72083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72084     return 0;
72085   }
72086   std::string arg1_str(jarg1);
72087   arg1 = &arg1_str;
72088   argp2 = (Dali::ImageDimensions *)jarg2;
72089   if (!argp2) {
72090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72091     return 0;
72092   }
72093   arg2 = *argp2;
72094   {
72095     try {
72096       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72097     } catch (std::out_of_range& e) {
72098       {
72099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72100       };
72101     } catch (std::exception& e) {
72102       {
72103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72104       };
72105     } catch (Dali::DaliException e) {
72106       {
72107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72108       };
72109     } catch (...) {
72110       {
72111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72112       };
72113     }
72114   }
72115
72116   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72117
72118   //argout typemap for const std::string&
72119
72120   return jresult;
72121 }
72122
72123
72124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72125   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72126
72127   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72128   {
72129     try {
72130       delete arg1;
72131     } catch (std::out_of_range& e) {
72132       {
72133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72134       };
72135     } catch (std::exception& e) {
72136       {
72137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72138       };
72139     } catch (Dali::DaliException e) {
72140       {
72141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72142       };
72143     } catch (...) {
72144       {
72145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72146       };
72147     }
72148   }
72149
72150 }
72151
72152
72153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72154   void * jresult ;
72155   Dali::Toolkit::ImageView *arg1 = 0 ;
72156   Dali::Toolkit::ImageView *result = 0 ;
72157
72158   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72159   if (!arg1) {
72160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72161     return 0;
72162   }
72163   {
72164     try {
72165       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72166     } catch (std::out_of_range& e) {
72167       {
72168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72169       };
72170     } catch (std::exception& e) {
72171       {
72172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72173       };
72174     } catch (Dali::DaliException e) {
72175       {
72176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72177       };
72178     } catch (...) {
72179       {
72180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72181       };
72182     }
72183   }
72184
72185   jresult = (void *)result;
72186   return jresult;
72187 }
72188
72189
72190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72191   void * jresult ;
72192   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72193   Dali::Toolkit::ImageView *arg2 = 0 ;
72194   Dali::Toolkit::ImageView *result = 0 ;
72195
72196   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72197   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72198   if (!arg2) {
72199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72200     return 0;
72201   }
72202   {
72203     try {
72204       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72205     } catch (std::out_of_range& e) {
72206       {
72207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72208       };
72209     } catch (std::exception& e) {
72210       {
72211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72212       };
72213     } catch (Dali::DaliException e) {
72214       {
72215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72216       };
72217     } catch (...) {
72218       {
72219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72220       };
72221     }
72222   }
72223
72224   jresult = (void *)result;
72225   return jresult;
72226 }
72227
72228
72229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72230   void * jresult ;
72231   Dali::BaseHandle arg1 ;
72232   Dali::BaseHandle *argp1 ;
72233   Dali::Toolkit::ImageView result;
72234
72235   argp1 = (Dali::BaseHandle *)jarg1;
72236   if (!argp1) {
72237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72238     return 0;
72239   }
72240   arg1 = *argp1;
72241   {
72242     try {
72243       result = Dali::Toolkit::ImageView::DownCast(arg1);
72244     } catch (std::out_of_range& e) {
72245       {
72246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72247       };
72248     } catch (std::exception& e) {
72249       {
72250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72251       };
72252     } catch (Dali::DaliException e) {
72253       {
72254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72255       };
72256     } catch (...) {
72257       {
72258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72259       };
72260     }
72261   }
72262
72263   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72264   return jresult;
72265 }
72266
72267
72268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72269   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72270   Dali::Image arg2 ;
72271   Dali::Image *argp2 ;
72272
72273   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72274   argp2 = (Dali::Image *)jarg2;
72275   if (!argp2) {
72276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72277     return ;
72278   }
72279   arg2 = *argp2;
72280   {
72281     try {
72282       (arg1)->SetImage(arg2);
72283     } catch (std::out_of_range& e) {
72284       {
72285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72286       };
72287     } catch (std::exception& e) {
72288       {
72289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72290       };
72291     } catch (Dali::DaliException e) {
72292       {
72293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72294       };
72295     } catch (...) {
72296       {
72297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72298       };
72299     }
72300   }
72301
72302 }
72303
72304
72305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72306   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72307   std::string *arg2 = 0 ;
72308
72309   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72310   if (!jarg2) {
72311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72312     return ;
72313   }
72314   std::string arg2_str(jarg2);
72315   arg2 = &arg2_str;
72316   {
72317     try {
72318       (arg1)->SetImage((std::string const &)*arg2);
72319     } catch (std::out_of_range& e) {
72320       {
72321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72322       };
72323     } catch (std::exception& e) {
72324       {
72325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72326       };
72327     } catch (Dali::DaliException e) {
72328       {
72329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72330       };
72331     } catch (...) {
72332       {
72333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72334       };
72335     }
72336   }
72337
72338
72339   //argout typemap for const std::string&
72340
72341 }
72342
72343
72344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72345   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72346   std::string *arg2 = 0 ;
72347   Dali::ImageDimensions arg3 ;
72348   Dali::ImageDimensions *argp3 ;
72349
72350   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72351   if (!jarg2) {
72352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72353     return ;
72354   }
72355   std::string arg2_str(jarg2);
72356   arg2 = &arg2_str;
72357   argp3 = (Dali::ImageDimensions *)jarg3;
72358   if (!argp3) {
72359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72360     return ;
72361   }
72362   arg3 = *argp3;
72363   {
72364     try {
72365       (arg1)->SetImage((std::string const &)*arg2,arg3);
72366     } catch (std::out_of_range& e) {
72367       {
72368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72369       };
72370     } catch (std::exception& e) {
72371       {
72372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72373       };
72374     } catch (Dali::DaliException e) {
72375       {
72376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72377       };
72378     } catch (...) {
72379       {
72380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72381       };
72382     }
72383   }
72384
72385
72386   //argout typemap for const std::string&
72387
72388 }
72389
72390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72391   void * jresult ;
72392   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72393   Dali::Image result;
72394
72395   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72396   {
72397     try {
72398       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72399     } catch (std::out_of_range& e) {
72400       {
72401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72402       };
72403     } catch (std::exception& e) {
72404       {
72405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72406       };
72407     } catch (Dali::DaliException e) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72410       };
72411     } catch (...) {
72412       {
72413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72414       };
72415     }
72416   }
72417
72418   jresult = new Dali::Image((const Dali::Image &)result);
72419   return jresult;
72420 }
72421
72422
72423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72424   int jresult ;
72425   int result;
72426
72427   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72428   jresult = (int)result;
72429   return jresult;
72430 }
72431
72432
72433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72434   int jresult ;
72435   int result;
72436
72437   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72438   jresult = (int)result;
72439   return jresult;
72440 }
72441
72442
72443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72444   int jresult ;
72445   int result;
72446
72447   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72448   jresult = (int)result;
72449   return jresult;
72450 }
72451
72452
72453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72454   int jresult ;
72455   int result;
72456
72457   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72458   jresult = (int)result;
72459   return jresult;
72460 }
72461
72462
72463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72464   int jresult ;
72465   int result;
72466
72467   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72468   jresult = (int)result;
72469   return jresult;
72470 }
72471
72472
72473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72474   int jresult ;
72475   int result;
72476
72477   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72478   jresult = (int)result;
72479   return jresult;
72480 }
72481
72482
72483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72484   int jresult ;
72485   int result;
72486
72487   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72488   jresult = (int)result;
72489   return jresult;
72490 }
72491
72492
72493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72494   int jresult ;
72495   int result;
72496
72497   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72498   jresult = (int)result;
72499   return jresult;
72500 }
72501
72502
72503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72504   void * jresult ;
72505   Dali::Toolkit::Model3dView::Property *result = 0 ;
72506
72507   {
72508     try {
72509       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72510     } catch (std::out_of_range& e) {
72511       {
72512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72513       };
72514     } catch (std::exception& e) {
72515       {
72516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72517       };
72518     } catch (Dali::DaliException e) {
72519       {
72520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72521       };
72522     } catch (...) {
72523       {
72524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72525       };
72526     }
72527   }
72528
72529   jresult = (void *)result;
72530   return jresult;
72531 }
72532
72533
72534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72535   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72536
72537   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72538   {
72539     try {
72540       delete arg1;
72541     } catch (std::out_of_range& e) {
72542       {
72543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72544       };
72545     } catch (std::exception& e) {
72546       {
72547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72548       };
72549     } catch (Dali::DaliException e) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72552       };
72553     } catch (...) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72556       };
72557     }
72558   }
72559
72560 }
72561
72562
72563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72564   void * jresult ;
72565   Dali::Toolkit::Model3dView result;
72566
72567   {
72568     try {
72569       result = Dali::Toolkit::Model3dView::New();
72570     } catch (std::out_of_range& e) {
72571       {
72572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72573       };
72574     } catch (std::exception& e) {
72575       {
72576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72577       };
72578     } catch (Dali::DaliException e) {
72579       {
72580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72581       };
72582     } catch (...) {
72583       {
72584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72585       };
72586     }
72587   }
72588
72589   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72590   return jresult;
72591 }
72592
72593
72594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72595   void * jresult ;
72596   std::string *arg1 = 0 ;
72597   std::string *arg2 = 0 ;
72598   std::string *arg3 = 0 ;
72599   Dali::Toolkit::Model3dView result;
72600
72601   if (!jarg1) {
72602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72603     return 0;
72604   }
72605   std::string arg1_str(jarg1);
72606   arg1 = &arg1_str;
72607   if (!jarg2) {
72608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72609     return 0;
72610   }
72611   std::string arg2_str(jarg2);
72612   arg2 = &arg2_str;
72613   if (!jarg3) {
72614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72615     return 0;
72616   }
72617   std::string arg3_str(jarg3);
72618   arg3 = &arg3_str;
72619   {
72620     try {
72621       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72622     } catch (std::out_of_range& e) {
72623       {
72624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72625       };
72626     } catch (std::exception& e) {
72627       {
72628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72629       };
72630     } catch (Dali::DaliException e) {
72631       {
72632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72633       };
72634     } catch (...) {
72635       {
72636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72637       };
72638     }
72639   }
72640
72641   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72642
72643   //argout typemap for const std::string&
72644
72645
72646   //argout typemap for const std::string&
72647
72648
72649   //argout typemap for const std::string&
72650
72651   return jresult;
72652 }
72653
72654
72655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72656   void * jresult ;
72657   Dali::Toolkit::Model3dView *result = 0 ;
72658
72659   {
72660     try {
72661       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72662     } catch (std::out_of_range& e) {
72663       {
72664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72665       };
72666     } catch (std::exception& e) {
72667       {
72668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72669       };
72670     } catch (Dali::DaliException e) {
72671       {
72672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72673       };
72674     } catch (...) {
72675       {
72676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72677       };
72678     }
72679   }
72680
72681   jresult = (void *)result;
72682   return jresult;
72683 }
72684
72685
72686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72687   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72688
72689   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72690   {
72691     try {
72692       delete arg1;
72693     } catch (std::out_of_range& e) {
72694       {
72695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72696       };
72697     } catch (std::exception& e) {
72698       {
72699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72700       };
72701     } catch (Dali::DaliException e) {
72702       {
72703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72704       };
72705     } catch (...) {
72706       {
72707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72708       };
72709     }
72710   }
72711
72712 }
72713
72714
72715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72716   void * jresult ;
72717   Dali::Toolkit::Model3dView *arg1 = 0 ;
72718   Dali::Toolkit::Model3dView *result = 0 ;
72719
72720   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72721   if (!arg1) {
72722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72723     return 0;
72724   }
72725   {
72726     try {
72727       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72728     } catch (std::out_of_range& e) {
72729       {
72730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72731       };
72732     } catch (std::exception& e) {
72733       {
72734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72735       };
72736     } catch (Dali::DaliException e) {
72737       {
72738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72739       };
72740     } catch (...) {
72741       {
72742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72743       };
72744     }
72745   }
72746
72747   jresult = (void *)result;
72748   return jresult;
72749 }
72750
72751
72752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72753   void * jresult ;
72754   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72755   Dali::Toolkit::Model3dView *arg2 = 0 ;
72756   Dali::Toolkit::Model3dView *result = 0 ;
72757
72758   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72759   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72760   if (!arg2) {
72761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72762     return 0;
72763   }
72764   {
72765     try {
72766       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72767     } catch (std::out_of_range& e) {
72768       {
72769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72770       };
72771     } catch (std::exception& e) {
72772       {
72773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72774       };
72775     } catch (Dali::DaliException e) {
72776       {
72777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72778       };
72779     } catch (...) {
72780       {
72781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72782       };
72783     }
72784   }
72785
72786   jresult = (void *)result;
72787   return jresult;
72788 }
72789
72790
72791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72792   void * jresult ;
72793   Dali::BaseHandle arg1 ;
72794   Dali::BaseHandle *argp1 ;
72795   Dali::Toolkit::Model3dView result;
72796
72797   argp1 = (Dali::BaseHandle *)jarg1;
72798   if (!argp1) {
72799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72800     return 0;
72801   }
72802   arg1 = *argp1;
72803   {
72804     try {
72805       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72806     } catch (std::out_of_range& e) {
72807       {
72808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72809       };
72810     } catch (std::exception& e) {
72811       {
72812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72813       };
72814     } catch (Dali::DaliException e) {
72815       {
72816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72817       };
72818     } catch (...) {
72819       {
72820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72821       };
72822     }
72823   }
72824
72825   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72826   return jresult;
72827 }
72828
72829
72830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72831   int jresult ;
72832   int result;
72833
72834   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72835   jresult = (int)result;
72836   return jresult;
72837 }
72838
72839
72840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72841   int jresult ;
72842   int result;
72843
72844   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72845   jresult = (int)result;
72846   return jresult;
72847 }
72848
72849
72850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72851   int jresult ;
72852   int result;
72853
72854   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72855   jresult = (int)result;
72856   return jresult;
72857 }
72858
72859
72860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72861   int jresult ;
72862   int result;
72863
72864   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72865   jresult = (int)result;
72866   return jresult;
72867 }
72868
72869
72870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72871   int jresult ;
72872   int result;
72873
72874   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72875   jresult = (int)result;
72876   return jresult;
72877 }
72878
72879
72880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72881   int jresult ;
72882   int result;
72883
72884   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72885   jresult = (int)result;
72886   return jresult;
72887 }
72888
72889
72890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72891   int jresult ;
72892   int result;
72893
72894   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72895   jresult = (int)result;
72896   return jresult;
72897 }
72898
72899
72900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72901   int jresult ;
72902   int result;
72903
72904   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72905   jresult = (int)result;
72906   return jresult;
72907 }
72908
72909
72910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72911   int jresult ;
72912   int result;
72913
72914   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72915   jresult = (int)result;
72916   return jresult;
72917 }
72918
72919
72920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72921   void * jresult ;
72922   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72923
72924   {
72925     try {
72926       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72927     } catch (std::out_of_range& e) {
72928       {
72929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72930       };
72931     } catch (std::exception& e) {
72932       {
72933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72934       };
72935     } catch (Dali::DaliException e) {
72936       {
72937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72938       };
72939     } catch (...) {
72940       {
72941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72942       };
72943     }
72944   }
72945
72946   jresult = (void *)result;
72947   return jresult;
72948 }
72949
72950
72951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72952   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72953
72954   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72955   {
72956     try {
72957       delete arg1;
72958     } catch (std::out_of_range& e) {
72959       {
72960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72961       };
72962     } catch (std::exception& e) {
72963       {
72964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72965       };
72966     } catch (Dali::DaliException e) {
72967       {
72968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72969       };
72970     } catch (...) {
72971       {
72972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72973       };
72974     }
72975   }
72976
72977 }
72978
72979
72980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72981   void * jresult ;
72982   Dali::Toolkit::ScrollBar *result = 0 ;
72983
72984   {
72985     try {
72986       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72987     } catch (std::out_of_range& e) {
72988       {
72989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72990       };
72991     } catch (std::exception& e) {
72992       {
72993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72994       };
72995     } catch (Dali::DaliException e) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72998       };
72999     } catch (...) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73002       };
73003     }
73004   }
73005
73006   jresult = (void *)result;
73007   return jresult;
73008 }
73009
73010
73011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73012   void * jresult ;
73013   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73014   Dali::Toolkit::ScrollBar *result = 0 ;
73015
73016   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73017   if (!arg1) {
73018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73019     return 0;
73020   }
73021   {
73022     try {
73023       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73024     } catch (std::out_of_range& e) {
73025       {
73026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73027       };
73028     } catch (std::exception& e) {
73029       {
73030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73031       };
73032     } catch (Dali::DaliException e) {
73033       {
73034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73035       };
73036     } catch (...) {
73037       {
73038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73039       };
73040     }
73041   }
73042
73043   jresult = (void *)result;
73044   return jresult;
73045 }
73046
73047
73048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73049   void * jresult ;
73050   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73051   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73052   Dali::Toolkit::ScrollBar *result = 0 ;
73053
73054   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73055   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73056   if (!arg2) {
73057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73058     return 0;
73059   }
73060   {
73061     try {
73062       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73063     } catch (std::out_of_range& e) {
73064       {
73065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73066       };
73067     } catch (std::exception& e) {
73068       {
73069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73070       };
73071     } catch (Dali::DaliException e) {
73072       {
73073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73074       };
73075     } catch (...) {
73076       {
73077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73078       };
73079     }
73080   }
73081
73082   jresult = (void *)result;
73083   return jresult;
73084 }
73085
73086
73087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73088   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73089
73090   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73091   {
73092     try {
73093       delete arg1;
73094     } catch (std::out_of_range& e) {
73095       {
73096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73097       };
73098     } catch (std::exception& e) {
73099       {
73100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73101       };
73102     } catch (Dali::DaliException e) {
73103       {
73104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73105       };
73106     } catch (...) {
73107       {
73108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73109       };
73110     }
73111   }
73112
73113 }
73114
73115
73116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73117   void * jresult ;
73118   Dali::Toolkit::ScrollBar::Direction arg1 ;
73119   Dali::Toolkit::ScrollBar result;
73120
73121   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73122   {
73123     try {
73124       result = Dali::Toolkit::ScrollBar::New(arg1);
73125     } catch (std::out_of_range& e) {
73126       {
73127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73128       };
73129     } catch (std::exception& e) {
73130       {
73131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73132       };
73133     } catch (Dali::DaliException e) {
73134       {
73135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73136       };
73137     } catch (...) {
73138       {
73139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73140       };
73141     }
73142   }
73143
73144   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73145   return jresult;
73146 }
73147
73148
73149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73150   void * jresult ;
73151   Dali::Toolkit::ScrollBar result;
73152
73153   {
73154     try {
73155       result = Dali::Toolkit::ScrollBar::New();
73156     } catch (std::out_of_range& e) {
73157       {
73158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73159       };
73160     } catch (std::exception& e) {
73161       {
73162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73163       };
73164     } catch (Dali::DaliException e) {
73165       {
73166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73167       };
73168     } catch (...) {
73169       {
73170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73171       };
73172     }
73173   }
73174
73175   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73176   return jresult;
73177 }
73178
73179
73180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73181   void * jresult ;
73182   Dali::BaseHandle arg1 ;
73183   Dali::BaseHandle *argp1 ;
73184   Dali::Toolkit::ScrollBar result;
73185
73186   argp1 = (Dali::BaseHandle *)jarg1;
73187   if (!argp1) {
73188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73189     return 0;
73190   }
73191   arg1 = *argp1;
73192   {
73193     try {
73194       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73195     } catch (std::out_of_range& e) {
73196       {
73197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73198       };
73199     } catch (std::exception& e) {
73200       {
73201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73202       };
73203     } catch (Dali::DaliException e) {
73204       {
73205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73206       };
73207     } catch (...) {
73208       {
73209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73210       };
73211     }
73212   }
73213
73214   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73215   return jresult;
73216 }
73217
73218
73219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73220   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73221   Dali::Handle arg2 ;
73222   Dali::Property::Index arg3 ;
73223   Dali::Property::Index arg4 ;
73224   Dali::Property::Index arg5 ;
73225   Dali::Property::Index arg6 ;
73226   Dali::Handle *argp2 ;
73227
73228   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73229   argp2 = (Dali::Handle *)jarg2;
73230   if (!argp2) {
73231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73232     return ;
73233   }
73234   arg2 = *argp2;
73235   arg3 = (Dali::Property::Index)jarg3;
73236   arg4 = (Dali::Property::Index)jarg4;
73237   arg5 = (Dali::Property::Index)jarg5;
73238   arg6 = (Dali::Property::Index)jarg6;
73239   {
73240     try {
73241       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73242     } catch (std::out_of_range& e) {
73243       {
73244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73245       };
73246     } catch (std::exception& e) {
73247       {
73248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73249       };
73250     } catch (Dali::DaliException e) {
73251       {
73252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73253       };
73254     } catch (...) {
73255       {
73256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73257       };
73258     }
73259   }
73260
73261 }
73262
73263
73264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73265   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73266   Dali::Actor arg2 ;
73267   Dali::Actor *argp2 ;
73268
73269   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73270   argp2 = (Dali::Actor *)jarg2;
73271   if (!argp2) {
73272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73273     return ;
73274   }
73275   arg2 = *argp2;
73276   {
73277     try {
73278       (arg1)->SetScrollIndicator(arg2);
73279     } catch (std::out_of_range& e) {
73280       {
73281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73282       };
73283     } catch (std::exception& e) {
73284       {
73285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73286       };
73287     } catch (Dali::DaliException e) {
73288       {
73289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73290       };
73291     } catch (...) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73294       };
73295     }
73296   }
73297
73298 }
73299
73300
73301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73302   void * jresult ;
73303   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73304   Dali::Actor result;
73305
73306   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73307   {
73308     try {
73309       result = (arg1)->GetScrollIndicator();
73310     } catch (std::out_of_range& e) {
73311       {
73312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73313       };
73314     } catch (std::exception& e) {
73315       {
73316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (Dali::DaliException e) {
73319       {
73320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73321       };
73322     } catch (...) {
73323       {
73324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73325       };
73326     }
73327   }
73328
73329   jresult = new Dali::Actor((const Dali::Actor &)result);
73330   return jresult;
73331 }
73332
73333
73334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73335   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73336   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73337
73338   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73339   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73340   if (!arg2) {
73341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73342     return ;
73343   }
73344   {
73345     try {
73346       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73347     } catch (std::out_of_range& e) {
73348       {
73349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73350       };
73351     } catch (std::exception& e) {
73352       {
73353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73354       };
73355     } catch (Dali::DaliException e) {
73356       {
73357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73358       };
73359     } catch (...) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73362       };
73363     }
73364   }
73365
73366 }
73367
73368
73369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73370   void * jresult ;
73371   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73372
73373   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73374   {
73375     try {
73376       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()));
73377     } catch (std::out_of_range& e) {
73378       {
73379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73380       };
73381     } catch (std::exception& e) {
73382       {
73383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73384       };
73385     } catch (...) {
73386       {
73387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73388       };
73389     }
73390   }
73391   return jresult;
73392 }
73393
73394
73395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73396   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73397   Dali::Toolkit::ScrollBar::Direction arg2 ;
73398
73399   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73400   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73401   {
73402     try {
73403       (arg1)->SetScrollDirection(arg2);
73404     } catch (std::out_of_range& e) {
73405       {
73406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73407       };
73408     } catch (std::exception& e) {
73409       {
73410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73411       };
73412     } catch (Dali::DaliException e) {
73413       {
73414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73415       };
73416     } catch (...) {
73417       {
73418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73419       };
73420     }
73421   }
73422
73423 }
73424
73425
73426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73427   int jresult ;
73428   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73429   Dali::Toolkit::ScrollBar::Direction result;
73430
73431   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73432   {
73433     try {
73434       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73435     } catch (std::out_of_range& e) {
73436       {
73437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73438       };
73439     } catch (std::exception& e) {
73440       {
73441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73442       };
73443     } catch (Dali::DaliException e) {
73444       {
73445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73446       };
73447     } catch (...) {
73448       {
73449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73450       };
73451     }
73452   }
73453
73454   jresult = (int)result;
73455   return jresult;
73456 }
73457
73458
73459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73460   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73461   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73462
73463   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73464   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73465   {
73466     try {
73467       (arg1)->SetIndicatorHeightPolicy(arg2);
73468     } catch (std::out_of_range& e) {
73469       {
73470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73471       };
73472     } catch (std::exception& e) {
73473       {
73474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73475       };
73476     } catch (Dali::DaliException e) {
73477       {
73478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73479       };
73480     } catch (...) {
73481       {
73482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73483       };
73484     }
73485   }
73486
73487 }
73488
73489
73490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73491   int jresult ;
73492   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73493   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73494
73495   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73496   {
73497     try {
73498       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73499     } catch (std::out_of_range& e) {
73500       {
73501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73502       };
73503     } catch (std::exception& e) {
73504       {
73505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73506       };
73507     } catch (Dali::DaliException e) {
73508       {
73509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73510       };
73511     } catch (...) {
73512       {
73513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73514       };
73515     }
73516   }
73517
73518   jresult = (int)result;
73519   return jresult;
73520 }
73521
73522
73523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73524   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73525   float arg2 ;
73526
73527   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73528   arg2 = (float)jarg2;
73529   {
73530     try {
73531       (arg1)->SetIndicatorFixedHeight(arg2);
73532     } catch (std::out_of_range& e) {
73533       {
73534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73535       };
73536     } catch (std::exception& e) {
73537       {
73538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73539       };
73540     } catch (Dali::DaliException e) {
73541       {
73542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73543       };
73544     } catch (...) {
73545       {
73546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73547       };
73548     }
73549   }
73550
73551 }
73552
73553
73554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73555   float jresult ;
73556   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73557   float result;
73558
73559   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73560   {
73561     try {
73562       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73563     } catch (std::out_of_range& e) {
73564       {
73565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73566       };
73567     } catch (std::exception& e) {
73568       {
73569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73570       };
73571     } catch (Dali::DaliException e) {
73572       {
73573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73574       };
73575     } catch (...) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73578       };
73579     }
73580   }
73581
73582   jresult = result;
73583   return jresult;
73584 }
73585
73586
73587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73588   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73589   float arg2 ;
73590
73591   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73592   arg2 = (float)jarg2;
73593   {
73594     try {
73595       (arg1)->SetIndicatorShowDuration(arg2);
73596     } catch (std::out_of_range& e) {
73597       {
73598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73599       };
73600     } catch (std::exception& e) {
73601       {
73602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73603       };
73604     } catch (Dali::DaliException e) {
73605       {
73606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73607       };
73608     } catch (...) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73611       };
73612     }
73613   }
73614
73615 }
73616
73617
73618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73619   float jresult ;
73620   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73621   float result;
73622
73623   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73624   {
73625     try {
73626       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73627     } catch (std::out_of_range& e) {
73628       {
73629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73630       };
73631     } catch (std::exception& e) {
73632       {
73633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73634       };
73635     } catch (Dali::DaliException e) {
73636       {
73637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73638       };
73639     } catch (...) {
73640       {
73641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73642       };
73643     }
73644   }
73645
73646   jresult = result;
73647   return jresult;
73648 }
73649
73650
73651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73652   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73653   float arg2 ;
73654
73655   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73656   arg2 = (float)jarg2;
73657   {
73658     try {
73659       (arg1)->SetIndicatorHideDuration(arg2);
73660     } catch (std::out_of_range& e) {
73661       {
73662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73663       };
73664     } catch (std::exception& e) {
73665       {
73666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73667       };
73668     } catch (Dali::DaliException e) {
73669       {
73670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73671       };
73672     } catch (...) {
73673       {
73674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73675       };
73676     }
73677   }
73678
73679 }
73680
73681
73682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73683   float jresult ;
73684   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73685   float result;
73686
73687   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73688   {
73689     try {
73690       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73691     } catch (std::out_of_range& e) {
73692       {
73693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73694       };
73695     } catch (std::exception& e) {
73696       {
73697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73698       };
73699     } catch (Dali::DaliException e) {
73700       {
73701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73702       };
73703     } catch (...) {
73704       {
73705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73706       };
73707     }
73708   }
73709
73710   jresult = result;
73711   return jresult;
73712 }
73713
73714
73715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73716   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73717
73718   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73719   {
73720     try {
73721       (arg1)->ShowIndicator();
73722     } catch (std::out_of_range& e) {
73723       {
73724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73725       };
73726     } catch (std::exception& e) {
73727       {
73728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73729       };
73730     } catch (Dali::DaliException e) {
73731       {
73732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73733       };
73734     } catch (...) {
73735       {
73736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73737       };
73738     }
73739   }
73740
73741 }
73742
73743
73744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73745   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73746
73747   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73748   {
73749     try {
73750       (arg1)->HideIndicator();
73751     } catch (std::out_of_range& e) {
73752       {
73753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73754       };
73755     } catch (std::exception& e) {
73756       {
73757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73758       };
73759     } catch (Dali::DaliException e) {
73760       {
73761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73762       };
73763     } catch (...) {
73764       {
73765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73766       };
73767     }
73768   }
73769
73770 }
73771
73772
73773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73774   void * jresult ;
73775   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73776   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73777
73778   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73779   {
73780     try {
73781       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73782     } catch (std::out_of_range& e) {
73783       {
73784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73785       };
73786     } catch (std::exception& e) {
73787       {
73788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73789       };
73790     } catch (Dali::DaliException e) {
73791       {
73792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73793       };
73794     } catch (...) {
73795       {
73796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73797       };
73798     }
73799   }
73800
73801   jresult = (void *)result;
73802   return jresult;
73803 }
73804
73805
73806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73807   void * jresult ;
73808   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73809   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73810
73811   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73812   {
73813     try {
73814       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73815     } catch (std::out_of_range& e) {
73816       {
73817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73818       };
73819     } catch (std::exception& e) {
73820       {
73821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73822       };
73823     } catch (Dali::DaliException e) {
73824       {
73825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73826       };
73827     } catch (...) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73830       };
73831     }
73832   }
73833
73834   jresult = (void *)result;
73835   return jresult;
73836 }
73837
73838
73839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73840   int jresult ;
73841   int result;
73842
73843   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73844   jresult = (int)result;
73845   return jresult;
73846 }
73847
73848
73849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73850   int jresult ;
73851   int result;
73852
73853   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73854   jresult = (int)result;
73855   return jresult;
73856 }
73857
73858
73859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73860   int jresult ;
73861   int result;
73862
73863   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73864   jresult = (int)result;
73865   return jresult;
73866 }
73867
73868
73869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73870   int jresult ;
73871   int result;
73872
73873   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73874   jresult = (int)result;
73875   return jresult;
73876 }
73877
73878
73879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73880   int jresult ;
73881   int result;
73882
73883   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73884   jresult = (int)result;
73885   return jresult;
73886 }
73887
73888
73889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73890   int jresult ;
73891   int result;
73892
73893   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73894   jresult = (int)result;
73895   return jresult;
73896 }
73897
73898
73899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73900   int jresult ;
73901   int result;
73902
73903   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73904   jresult = (int)result;
73905   return jresult;
73906 }
73907
73908
73909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73910   int jresult ;
73911   int result;
73912
73913   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73914   jresult = (int)result;
73915   return jresult;
73916 }
73917
73918
73919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73920   int jresult ;
73921   int result;
73922
73923   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73924   jresult = (int)result;
73925   return jresult;
73926 }
73927
73928
73929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73930   int jresult ;
73931   int result;
73932
73933   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73934   jresult = (int)result;
73935   return jresult;
73936 }
73937
73938
73939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73940   int jresult ;
73941   int result;
73942
73943   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73944   jresult = (int)result;
73945   return jresult;
73946 }
73947
73948
73949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73950   int jresult ;
73951   int result;
73952
73953   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73954   jresult = (int)result;
73955   return jresult;
73956 }
73957
73958
73959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73960   int jresult ;
73961   int result;
73962
73963   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73964   jresult = (int)result;
73965   return jresult;
73966 }
73967
73968
73969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73970   int jresult ;
73971   int result;
73972
73973   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73974   jresult = (int)result;
73975   return jresult;
73976 }
73977
73978
73979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73980   void * jresult ;
73981   Dali::Toolkit::Scrollable::Property *result = 0 ;
73982
73983   {
73984     try {
73985       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73986     } catch (std::out_of_range& e) {
73987       {
73988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73989       };
73990     } catch (std::exception& e) {
73991       {
73992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73993       };
73994     } catch (Dali::DaliException e) {
73995       {
73996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73997       };
73998     } catch (...) {
73999       {
74000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74001       };
74002     }
74003   }
74004
74005   jresult = (void *)result;
74006   return jresult;
74007 }
74008
74009
74010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74011   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74012
74013   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74014   {
74015     try {
74016       delete arg1;
74017     } catch (std::out_of_range& e) {
74018       {
74019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74020       };
74021     } catch (std::exception& e) {
74022       {
74023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74024       };
74025     } catch (Dali::DaliException e) {
74026       {
74027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74028       };
74029     } catch (...) {
74030       {
74031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74032       };
74033     }
74034   }
74035
74036 }
74037
74038
74039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74040   void * jresult ;
74041   Dali::Toolkit::Scrollable *result = 0 ;
74042
74043   {
74044     try {
74045       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74046     } catch (std::out_of_range& e) {
74047       {
74048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74049       };
74050     } catch (std::exception& e) {
74051       {
74052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74053       };
74054     } catch (Dali::DaliException e) {
74055       {
74056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74057       };
74058     } catch (...) {
74059       {
74060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74061       };
74062     }
74063   }
74064
74065   jresult = (void *)result;
74066   return jresult;
74067 }
74068
74069
74070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74071   void * jresult ;
74072   Dali::Toolkit::Scrollable *arg1 = 0 ;
74073   Dali::Toolkit::Scrollable *result = 0 ;
74074
74075   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74076   if (!arg1) {
74077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74078     return 0;
74079   }
74080   {
74081     try {
74082       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74083     } catch (std::out_of_range& e) {
74084       {
74085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74086       };
74087     } catch (std::exception& e) {
74088       {
74089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74090       };
74091     } catch (Dali::DaliException e) {
74092       {
74093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74094       };
74095     } catch (...) {
74096       {
74097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74098       };
74099     }
74100   }
74101
74102   jresult = (void *)result;
74103   return jresult;
74104 }
74105
74106
74107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74108   void * jresult ;
74109   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74110   Dali::Toolkit::Scrollable *arg2 = 0 ;
74111   Dali::Toolkit::Scrollable *result = 0 ;
74112
74113   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74114   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74115   if (!arg2) {
74116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74117     return 0;
74118   }
74119   {
74120     try {
74121       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74122     } catch (std::out_of_range& e) {
74123       {
74124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74125       };
74126     } catch (std::exception& e) {
74127       {
74128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74129       };
74130     } catch (Dali::DaliException e) {
74131       {
74132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74133       };
74134     } catch (...) {
74135       {
74136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74137       };
74138     }
74139   }
74140
74141   jresult = (void *)result;
74142   return jresult;
74143 }
74144
74145
74146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74147   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74148
74149   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74150   {
74151     try {
74152       delete arg1;
74153     } catch (std::out_of_range& e) {
74154       {
74155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74156       };
74157     } catch (std::exception& e) {
74158       {
74159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74160       };
74161     } catch (Dali::DaliException e) {
74162       {
74163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74164       };
74165     } catch (...) {
74166       {
74167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74168       };
74169     }
74170   }
74171
74172 }
74173
74174
74175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74176   void * jresult ;
74177   Dali::BaseHandle arg1 ;
74178   Dali::BaseHandle *argp1 ;
74179   Dali::Toolkit::Scrollable result;
74180
74181   argp1 = (Dali::BaseHandle *)jarg1;
74182   if (!argp1) {
74183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74184     return 0;
74185   }
74186   arg1 = *argp1;
74187   {
74188     try {
74189       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74190     } catch (std::out_of_range& e) {
74191       {
74192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74193       };
74194     } catch (std::exception& e) {
74195       {
74196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74197       };
74198     } catch (Dali::DaliException e) {
74199       {
74200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74201       };
74202     } catch (...) {
74203       {
74204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74205       };
74206     }
74207   }
74208
74209   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74210   return jresult;
74211 }
74212
74213
74214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74215   unsigned int jresult ;
74216   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74217   bool result;
74218
74219   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74220   {
74221     try {
74222       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74223     } catch (std::out_of_range& e) {
74224       {
74225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74226       };
74227     } catch (std::exception& e) {
74228       {
74229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74230       };
74231     } catch (Dali::DaliException e) {
74232       {
74233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74234       };
74235     } catch (...) {
74236       {
74237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74238       };
74239     }
74240   }
74241
74242   jresult = result;
74243   return jresult;
74244 }
74245
74246
74247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74248   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74249   bool arg2 ;
74250
74251   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74252   arg2 = jarg2 ? true : false;
74253   {
74254     try {
74255       (arg1)->SetOvershootEnabled(arg2);
74256     } catch (std::out_of_range& e) {
74257       {
74258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74259       };
74260     } catch (std::exception& e) {
74261       {
74262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74263       };
74264     } catch (Dali::DaliException e) {
74265       {
74266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74267       };
74268     } catch (...) {
74269       {
74270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74271       };
74272     }
74273   }
74274
74275 }
74276
74277
74278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74279   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74280   Dali::Vector4 *arg2 = 0 ;
74281
74282   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74283   arg2 = (Dali::Vector4 *)jarg2;
74284   if (!arg2) {
74285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74286     return ;
74287   }
74288   {
74289     try {
74290       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74291     } catch (std::out_of_range& e) {
74292       {
74293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74294       };
74295     } catch (std::exception& e) {
74296       {
74297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74298       };
74299     } catch (Dali::DaliException e) {
74300       {
74301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74302       };
74303     } catch (...) {
74304       {
74305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74306       };
74307     }
74308   }
74309
74310 }
74311
74312
74313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74314   void * jresult ;
74315   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74316   Dali::Vector4 result;
74317
74318   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74319   {
74320     try {
74321       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74322     } catch (std::out_of_range& e) {
74323       {
74324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74325       };
74326     } catch (std::exception& e) {
74327       {
74328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74329       };
74330     } catch (Dali::DaliException e) {
74331       {
74332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74333       };
74334     } catch (...) {
74335       {
74336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74337       };
74338     }
74339   }
74340
74341   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74342   return jresult;
74343 }
74344
74345
74346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74347   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74348   float arg2 ;
74349
74350   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74351   arg2 = (float)jarg2;
74352   {
74353     try {
74354       (arg1)->SetOvershootAnimationSpeed(arg2);
74355     } catch (std::out_of_range& e) {
74356       {
74357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74358       };
74359     } catch (std::exception& e) {
74360       {
74361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74362       };
74363     } catch (Dali::DaliException e) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74366       };
74367     } catch (...) {
74368       {
74369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74370       };
74371     }
74372   }
74373
74374 }
74375
74376
74377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74378   float jresult ;
74379   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74380   float result;
74381
74382   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74383   {
74384     try {
74385       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74386     } catch (std::out_of_range& e) {
74387       {
74388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74389       };
74390     } catch (std::exception& e) {
74391       {
74392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74393       };
74394     } catch (Dali::DaliException e) {
74395       {
74396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74397       };
74398     } catch (...) {
74399       {
74400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74401       };
74402     }
74403   }
74404
74405   jresult = result;
74406   return jresult;
74407 }
74408
74409
74410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74411   void * jresult ;
74412   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74413   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74414
74415   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74416   {
74417     try {
74418       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74419     } catch (std::out_of_range& e) {
74420       {
74421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74422       };
74423     } catch (std::exception& e) {
74424       {
74425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74426       };
74427     } catch (Dali::DaliException e) {
74428       {
74429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74430       };
74431     } catch (...) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74434       };
74435     }
74436   }
74437
74438   jresult = (void *)result;
74439   return jresult;
74440 }
74441
74442
74443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74444   void * jresult ;
74445   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74446   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74447
74448   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74449   {
74450     try {
74451       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74452     } catch (std::out_of_range& e) {
74453       {
74454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74455       };
74456     } catch (std::exception& e) {
74457       {
74458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74459       };
74460     } catch (Dali::DaliException e) {
74461       {
74462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74463       };
74464     } catch (...) {
74465       {
74466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74467       };
74468     }
74469   }
74470
74471   jresult = (void *)result;
74472   return jresult;
74473 }
74474
74475
74476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74477   void * jresult ;
74478   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74479   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74480
74481   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74482   {
74483     try {
74484       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74485     } catch (std::out_of_range& e) {
74486       {
74487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74488       };
74489     } catch (std::exception& e) {
74490       {
74491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74492       };
74493     } catch (Dali::DaliException e) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74496       };
74497     } catch (...) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74500       };
74501     }
74502   }
74503
74504   jresult = (void *)result;
74505   return jresult;
74506 }
74507
74508
74509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74510   unsigned int jresult ;
74511   Dali::Toolkit::ControlOrientation::Type arg1 ;
74512   bool result;
74513
74514   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74515   {
74516     try {
74517       result = (bool)Dali::Toolkit::IsVertical(arg1);
74518     } catch (std::out_of_range& e) {
74519       {
74520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74521       };
74522     } catch (std::exception& e) {
74523       {
74524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74525       };
74526     } catch (Dali::DaliException e) {
74527       {
74528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74529       };
74530     } catch (...) {
74531       {
74532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74533       };
74534     }
74535   }
74536
74537   jresult = result;
74538   return jresult;
74539 }
74540
74541
74542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74543   unsigned int jresult ;
74544   Dali::Toolkit::ControlOrientation::Type arg1 ;
74545   bool result;
74546
74547   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74548   {
74549     try {
74550       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74551     } catch (std::out_of_range& e) {
74552       {
74553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74554       };
74555     } catch (std::exception& e) {
74556       {
74557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74558       };
74559     } catch (Dali::DaliException e) {
74560       {
74561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74562       };
74563     } catch (...) {
74564       {
74565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74566       };
74567     }
74568   }
74569
74570   jresult = result;
74571   return jresult;
74572 }
74573
74574
74575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74576   void * jresult ;
74577   unsigned int arg1 ;
74578   unsigned int arg2 ;
74579   Dali::Toolkit::ItemRange *result = 0 ;
74580
74581   arg1 = (unsigned int)jarg1;
74582   arg2 = (unsigned int)jarg2;
74583   {
74584     try {
74585       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74586     } catch (std::out_of_range& e) {
74587       {
74588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74589       };
74590     } catch (std::exception& e) {
74591       {
74592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74593       };
74594     } catch (Dali::DaliException e) {
74595       {
74596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74597       };
74598     } catch (...) {
74599       {
74600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74601       };
74602     }
74603   }
74604
74605   jresult = (void *)result;
74606   return jresult;
74607 }
74608
74609
74610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74611   void * jresult ;
74612   Dali::Toolkit::ItemRange *arg1 = 0 ;
74613   Dali::Toolkit::ItemRange *result = 0 ;
74614
74615   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74616   if (!arg1) {
74617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74618     return 0;
74619   }
74620   {
74621     try {
74622       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74623     } catch (std::out_of_range& e) {
74624       {
74625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74626       };
74627     } catch (std::exception& e) {
74628       {
74629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74630       };
74631     } catch (Dali::DaliException e) {
74632       {
74633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74634       };
74635     } catch (...) {
74636       {
74637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74638       };
74639     }
74640   }
74641
74642   jresult = (void *)result;
74643   return jresult;
74644 }
74645
74646
74647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74648   void * jresult ;
74649   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74650   Dali::Toolkit::ItemRange *arg2 = 0 ;
74651   Dali::Toolkit::ItemRange *result = 0 ;
74652
74653   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74654   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74655   if (!arg2) {
74656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74657     return 0;
74658   }
74659   {
74660     try {
74661       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74662     } catch (std::out_of_range& e) {
74663       {
74664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74665       };
74666     } catch (std::exception& e) {
74667       {
74668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74669       };
74670     } catch (Dali::DaliException e) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74673       };
74674     } catch (...) {
74675       {
74676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74677       };
74678     }
74679   }
74680
74681   jresult = (void *)result;
74682   return jresult;
74683 }
74684
74685
74686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74687   unsigned int jresult ;
74688   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74689   unsigned int arg2 ;
74690   bool result;
74691
74692   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74693   arg2 = (unsigned int)jarg2;
74694   {
74695     try {
74696       result = (bool)(arg1)->Within(arg2);
74697     } catch (std::out_of_range& e) {
74698       {
74699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74700       };
74701     } catch (std::exception& e) {
74702       {
74703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74704       };
74705     } catch (Dali::DaliException e) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74708       };
74709     } catch (...) {
74710       {
74711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74712       };
74713     }
74714   }
74715
74716   jresult = result;
74717   return jresult;
74718 }
74719
74720
74721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74722   void * jresult ;
74723   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74724   Dali::Toolkit::ItemRange *arg2 = 0 ;
74725   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74726
74727   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74728   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74729   if (!arg2) {
74730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74731     return 0;
74732   }
74733   {
74734     try {
74735       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74736     } catch (std::out_of_range& e) {
74737       {
74738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74739       };
74740     } catch (std::exception& e) {
74741       {
74742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74743       };
74744     } catch (Dali::DaliException e) {
74745       {
74746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74747       };
74748     } catch (...) {
74749       {
74750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74751       };
74752     }
74753   }
74754
74755   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74756   return jresult;
74757 }
74758
74759
74760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74761   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74762   unsigned int arg2 ;
74763
74764   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74765   arg2 = (unsigned int)jarg2;
74766   if (arg1) (arg1)->begin = arg2;
74767 }
74768
74769
74770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74771   unsigned int jresult ;
74772   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74773   unsigned int result;
74774
74775   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74776   result = (unsigned int) ((arg1)->begin);
74777   jresult = result;
74778   return jresult;
74779 }
74780
74781
74782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74783   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74784   unsigned int arg2 ;
74785
74786   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74787   arg2 = (unsigned int)jarg2;
74788   if (arg1) (arg1)->end = arg2;
74789 }
74790
74791
74792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74793   unsigned int jresult ;
74794   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74795   unsigned int result;
74796
74797   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74798   result = (unsigned int) ((arg1)->end);
74799   jresult = result;
74800   return jresult;
74801 }
74802
74803
74804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74805   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74806
74807   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74808   {
74809     try {
74810       delete arg1;
74811     } catch (std::out_of_range& e) {
74812       {
74813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74814       };
74815     } catch (std::exception& e) {
74816       {
74817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74818       };
74819     } catch (Dali::DaliException e) {
74820       {
74821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74822       };
74823     } catch (...) {
74824       {
74825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74826       };
74827     }
74828   }
74829
74830 }
74831
74832
74833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74834   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74835
74836   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74837   {
74838     try {
74839       delete arg1;
74840     } catch (std::out_of_range& e) {
74841       {
74842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74843       };
74844     } catch (std::exception& e) {
74845       {
74846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74847       };
74848     } catch (Dali::DaliException e) {
74849       {
74850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74851       };
74852     } catch (...) {
74853       {
74854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74855       };
74856     }
74857   }
74858
74859 }
74860
74861
74862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74863   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74864   Dali::Toolkit::ControlOrientation::Type arg2 ;
74865
74866   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74867   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74868   {
74869     try {
74870       (arg1)->SetOrientation(arg2);
74871     } catch (std::out_of_range& e) {
74872       {
74873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74874       };
74875     } catch (std::exception& e) {
74876       {
74877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74878       };
74879     } catch (Dali::DaliException e) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74882       };
74883     } catch (...) {
74884       {
74885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74886       };
74887     }
74888   }
74889
74890 }
74891
74892
74893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74894   int jresult ;
74895   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74896   Dali::Toolkit::ControlOrientation::Type result;
74897
74898   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74899   {
74900     try {
74901       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74902     } catch (std::out_of_range& e) {
74903       {
74904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74905       };
74906     } catch (std::exception& e) {
74907       {
74908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74909       };
74910     } catch (Dali::DaliException e) {
74911       {
74912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74913       };
74914     } catch (...) {
74915       {
74916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74917       };
74918     }
74919   }
74920
74921   jresult = (int)result;
74922   return jresult;
74923 }
74924
74925
74926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74927   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74928   Dali::Property::Map *arg2 = 0 ;
74929
74930   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74931   arg2 = (Dali::Property::Map *)jarg2;
74932   if (!arg2) {
74933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74934     return ;
74935   }
74936   {
74937     try {
74938       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74939     } catch (std::out_of_range& e) {
74940       {
74941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74942       };
74943     } catch (std::exception& e) {
74944       {
74945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74946       };
74947     } catch (Dali::DaliException e) {
74948       {
74949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74950       };
74951     } catch (...) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74954       };
74955     }
74956   }
74957
74958 }
74959
74960
74961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74962   void * jresult ;
74963   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74964   Dali::Property::Map result;
74965
74966   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74967   {
74968     try {
74969       result = (arg1)->GetLayoutProperties();
74970     } catch (std::out_of_range& e) {
74971       {
74972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74973       };
74974     } catch (std::exception& e) {
74975       {
74976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74977       };
74978     } catch (Dali::DaliException e) {
74979       {
74980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74981       };
74982     } catch (...) {
74983       {
74984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74985       };
74986     }
74987   }
74988
74989   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74990   return jresult;
74991 }
74992
74993
74994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74995   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74996   unsigned int arg2 ;
74997   Dali::Vector3 *arg3 = 0 ;
74998   Dali::Vector3 *arg4 = 0 ;
74999
75000   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75001   arg2 = (unsigned int)jarg2;
75002   arg3 = (Dali::Vector3 *)jarg3;
75003   if (!arg3) {
75004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75005     return ;
75006   }
75007   arg4 = (Dali::Vector3 *)jarg4;
75008   if (!arg4) {
75009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75010     return ;
75011   }
75012   {
75013     try {
75014       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75015     } catch (std::out_of_range& e) {
75016       {
75017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75018       };
75019     } catch (std::exception& e) {
75020       {
75021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75022       };
75023     } catch (Dali::DaliException e) {
75024       {
75025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75026       };
75027     } catch (...) {
75028       {
75029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75030       };
75031     }
75032   }
75033
75034 }
75035
75036
75037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75038   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75039   Dali::Vector3 *arg2 = 0 ;
75040
75041   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75042   arg2 = (Dali::Vector3 *)jarg2;
75043   if (!arg2) {
75044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75045     return ;
75046   }
75047   {
75048     try {
75049       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75050     } catch (std::out_of_range& e) {
75051       {
75052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75053       };
75054     } catch (std::exception& e) {
75055       {
75056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75057       };
75058     } catch (Dali::DaliException e) {
75059       {
75060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75061       };
75062     } catch (...) {
75063       {
75064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75065       };
75066     }
75067   }
75068
75069 }
75070
75071
75072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75073   float jresult ;
75074   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75075   unsigned int arg2 ;
75076   Dali::Vector3 arg3 ;
75077   Dali::Vector3 *argp3 ;
75078   float result;
75079
75080   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75081   arg2 = (unsigned int)jarg2;
75082   argp3 = (Dali::Vector3 *)jarg3;
75083   if (!argp3) {
75084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75085     return 0;
75086   }
75087   arg3 = *argp3;
75088   {
75089     try {
75090       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75091     } catch (std::out_of_range& e) {
75092       {
75093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75094       };
75095     } catch (std::exception& e) {
75096       {
75097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75098       };
75099     } catch (Dali::DaliException e) {
75100       {
75101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75102       };
75103     } catch (...) {
75104       {
75105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75106       };
75107     }
75108   }
75109
75110   jresult = result;
75111   return jresult;
75112 }
75113
75114
75115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75116   float jresult ;
75117   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75118   float arg2 ;
75119   float result;
75120
75121   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75122   arg2 = (float)jarg2;
75123   {
75124     try {
75125       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75126     } catch (std::out_of_range& e) {
75127       {
75128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75129       };
75130     } catch (std::exception& e) {
75131       {
75132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75133       };
75134     } catch (Dali::DaliException e) {
75135       {
75136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75137       };
75138     } catch (...) {
75139       {
75140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75141       };
75142     }
75143   }
75144
75145   jresult = result;
75146   return jresult;
75147 }
75148
75149
75150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75151   float jresult ;
75152   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75153   unsigned int arg2 ;
75154   float result;
75155
75156   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75157   arg2 = (unsigned int)jarg2;
75158   {
75159     try {
75160       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75161     } catch (std::out_of_range& e) {
75162       {
75163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75164       };
75165     } catch (std::exception& e) {
75166       {
75167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75168       };
75169     } catch (Dali::DaliException e) {
75170       {
75171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75172       };
75173     } catch (...) {
75174       {
75175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75176       };
75177     }
75178   }
75179
75180   jresult = result;
75181   return jresult;
75182 }
75183
75184
75185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75186   void * jresult ;
75187   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75188   float arg2 ;
75189   Dali::Vector3 arg3 ;
75190   Dali::Vector3 *argp3 ;
75191   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75192
75193   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75194   arg2 = (float)jarg2;
75195   argp3 = (Dali::Vector3 *)jarg3;
75196   if (!argp3) {
75197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75198     return 0;
75199   }
75200   arg3 = *argp3;
75201   {
75202     try {
75203       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75204     } catch (std::out_of_range& e) {
75205       {
75206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75207       };
75208     } catch (std::exception& e) {
75209       {
75210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75211       };
75212     } catch (Dali::DaliException e) {
75213       {
75214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75215       };
75216     } catch (...) {
75217       {
75218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75219       };
75220     }
75221   }
75222
75223   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75224   return jresult;
75225 }
75226
75227
75228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75229   float jresult ;
75230   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75231   int arg2 ;
75232   float arg3 ;
75233   Dali::Vector3 *arg4 = 0 ;
75234   float result;
75235
75236   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75237   arg2 = (int)jarg2;
75238   arg3 = (float)jarg3;
75239   arg4 = (Dali::Vector3 *)jarg4;
75240   if (!arg4) {
75241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75242     return 0;
75243   }
75244   {
75245     try {
75246       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75247     } catch (std::out_of_range& e) {
75248       {
75249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75250       };
75251     } catch (std::exception& e) {
75252       {
75253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75254       };
75255     } catch (Dali::DaliException e) {
75256       {
75257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75258       };
75259     } catch (...) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75262       };
75263     }
75264   }
75265
75266   jresult = result;
75267   return jresult;
75268 }
75269
75270
75271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75272   unsigned int jresult ;
75273   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75274   Dali::Vector3 arg2 ;
75275   Dali::Vector3 *argp2 ;
75276   unsigned int result;
75277
75278   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75279   argp2 = (Dali::Vector3 *)jarg2;
75280   if (!argp2) {
75281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75282     return 0;
75283   }
75284   arg2 = *argp2;
75285   {
75286     try {
75287       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75288     } catch (std::out_of_range& e) {
75289       {
75290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75291       };
75292     } catch (std::exception& e) {
75293       {
75294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75295       };
75296     } catch (Dali::DaliException e) {
75297       {
75298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75299       };
75300     } catch (...) {
75301       {
75302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75303       };
75304     }
75305   }
75306
75307   jresult = result;
75308   return jresult;
75309 }
75310
75311
75312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75313   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75314   unsigned int arg2 ;
75315   Dali::Vector3 *arg3 = 0 ;
75316   Dali::Vector3 *arg4 = 0 ;
75317
75318   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75319   arg2 = (unsigned int)jarg2;
75320   arg3 = (Dali::Vector3 *)jarg3;
75321   if (!arg3) {
75322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75323     return ;
75324   }
75325   arg4 = (Dali::Vector3 *)jarg4;
75326   if (!arg4) {
75327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75328     return ;
75329   }
75330   {
75331     try {
75332       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75333     } catch (std::out_of_range& e) {
75334       {
75335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75336       };
75337     } catch (std::exception& e) {
75338       {
75339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75340       };
75341     } catch (Dali::DaliException e) {
75342       {
75343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75344       };
75345     } catch (...) {
75346       {
75347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75348       };
75349     }
75350   }
75351
75352 }
75353
75354
75355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75356   void * jresult ;
75357   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75358   Dali::Degree result;
75359
75360   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75361   {
75362     try {
75363       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75364     } catch (std::out_of_range& e) {
75365       {
75366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75367       };
75368     } catch (std::exception& e) {
75369       {
75370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75371       };
75372     } catch (Dali::DaliException e) {
75373       {
75374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75375       };
75376     } catch (...) {
75377       {
75378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75379       };
75380     }
75381   }
75382
75383   jresult = new Dali::Degree((const Dali::Degree &)result);
75384   return jresult;
75385 }
75386
75387
75388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75389   float jresult ;
75390   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75391   float result;
75392
75393   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75394   {
75395     try {
75396       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75397     } catch (std::out_of_range& e) {
75398       {
75399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75400       };
75401     } catch (std::exception& e) {
75402       {
75403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75404       };
75405     } catch (Dali::DaliException e) {
75406       {
75407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75408       };
75409     } catch (...) {
75410       {
75411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75412       };
75413     }
75414   }
75415
75416   jresult = result;
75417   return jresult;
75418 }
75419
75420
75421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75422   float jresult ;
75423   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75424   float result;
75425
75426   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75427   {
75428     try {
75429       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75430     } catch (std::out_of_range& e) {
75431       {
75432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75433       };
75434     } catch (std::exception& e) {
75435       {
75436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75437       };
75438     } catch (Dali::DaliException e) {
75439       {
75440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75441       };
75442     } catch (...) {
75443       {
75444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75445       };
75446     }
75447   }
75448
75449   jresult = result;
75450   return jresult;
75451 }
75452
75453
75454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75455   float jresult ;
75456   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75457   float result;
75458
75459   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75460   {
75461     try {
75462       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75463     } catch (std::out_of_range& e) {
75464       {
75465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75466       };
75467     } catch (std::exception& e) {
75468       {
75469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75470       };
75471     } catch (Dali::DaliException e) {
75472       {
75473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75474       };
75475     } catch (...) {
75476       {
75477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75478       };
75479     }
75480   }
75481
75482   jresult = result;
75483   return jresult;
75484 }
75485
75486
75487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75488   int jresult ;
75489   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75490   int arg2 ;
75491   int arg3 ;
75492   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75493   bool arg5 ;
75494   int result;
75495
75496   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75497   arg2 = (int)jarg2;
75498   arg3 = (int)jarg3;
75499   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75500   arg5 = jarg5 ? true : false;
75501   {
75502     try {
75503       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75504     } catch (std::out_of_range& e) {
75505       {
75506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75507       };
75508     } catch (std::exception& e) {
75509       {
75510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75511       };
75512     } catch (Dali::DaliException e) {
75513       {
75514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75515       };
75516     } catch (...) {
75517       {
75518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75519       };
75520     }
75521   }
75522
75523   jresult = result;
75524   return jresult;
75525 }
75526
75527
75528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75529   float jresult ;
75530   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75531   float result;
75532
75533   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75534   {
75535     try {
75536       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75537     } catch (std::out_of_range& e) {
75538       {
75539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75540       };
75541     } catch (std::exception& e) {
75542       {
75543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75544       };
75545     } catch (Dali::DaliException e) {
75546       {
75547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75548       };
75549     } catch (...) {
75550       {
75551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75552       };
75553     }
75554   }
75555
75556   jresult = result;
75557   return jresult;
75558 }
75559
75560
75561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75562   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75563   Dali::Actor *arg2 = 0 ;
75564   int arg3 ;
75565   Dali::Vector3 *arg4 = 0 ;
75566   Dali::Actor *arg5 = 0 ;
75567
75568   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75569   arg2 = (Dali::Actor *)jarg2;
75570   if (!arg2) {
75571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75572     return ;
75573   }
75574   arg3 = (int)jarg3;
75575   arg4 = (Dali::Vector3 *)jarg4;
75576   if (!arg4) {
75577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75578     return ;
75579   }
75580   arg5 = (Dali::Actor *)jarg5;
75581   if (!arg5) {
75582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75583     return ;
75584   }
75585   {
75586     try {
75587       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75588     } catch (std::out_of_range& e) {
75589       {
75590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75591       };
75592     } catch (std::exception& e) {
75593       {
75594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75595       };
75596     } catch (Dali::DaliException e) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75599       };
75600     } catch (...) {
75601       {
75602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75603       };
75604     }
75605   }
75606
75607 }
75608
75609
75610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75611   void * jresult ;
75612   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75613   int arg2 ;
75614   float arg3 ;
75615   Dali::Vector3 *arg4 = 0 ;
75616   Dali::Vector3 result;
75617
75618   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75619   arg2 = (int)jarg2;
75620   arg3 = (float)jarg3;
75621   arg4 = (Dali::Vector3 *)jarg4;
75622   if (!arg4) {
75623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75624     return 0;
75625   }
75626   {
75627     try {
75628       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75629     } catch (std::out_of_range& e) {
75630       {
75631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75632       };
75633     } catch (std::exception& e) {
75634       {
75635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75636       };
75637     } catch (Dali::DaliException e) {
75638       {
75639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75640       };
75641     } catch (...) {
75642       {
75643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75644       };
75645     }
75646   }
75647
75648   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75649   return jresult;
75650 }
75651
75652
75653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75654   void * jresult ;
75655   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75656   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75657
75658   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75659   {
75660     try {
75661       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75662     } catch (std::out_of_range& e) {
75663       {
75664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75665       };
75666     } catch (std::exception& e) {
75667       {
75668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75669       };
75670     } catch (Dali::DaliException e) {
75671       {
75672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75673       };
75674     } catch (...) {
75675       {
75676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75677       };
75678     }
75679   }
75680
75681   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75682   return jresult;
75683 }
75684
75685
75686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75687   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75688
75689   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75690   {
75691     try {
75692       delete arg1;
75693     } catch (std::out_of_range& e) {
75694       {
75695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75696       };
75697     } catch (std::exception& e) {
75698       {
75699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75700       };
75701     } catch (Dali::DaliException e) {
75702       {
75703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75704       };
75705     } catch (...) {
75706       {
75707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75708       };
75709     }
75710   }
75711
75712 }
75713
75714
75715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75716   unsigned int jresult ;
75717   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75718   unsigned int result;
75719
75720   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75721   {
75722     try {
75723       result = (unsigned int)(arg1)->GetNumberOfItems();
75724     } catch (std::out_of_range& e) {
75725       {
75726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75727       };
75728     } catch (std::exception& e) {
75729       {
75730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75731       };
75732     } catch (Dali::DaliException e) {
75733       {
75734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75735       };
75736     } catch (...) {
75737       {
75738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75739       };
75740     }
75741   }
75742
75743   jresult = result;
75744   return jresult;
75745 }
75746
75747
75748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75749   void * jresult ;
75750   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75751   unsigned int arg2 ;
75752   Dali::Actor result;
75753
75754   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75755   arg2 = (unsigned int)jarg2;
75756   {
75757     try {
75758       result = (arg1)->NewItem(arg2);
75759     } catch (std::out_of_range& e) {
75760       {
75761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75762       };
75763     } catch (std::exception& e) {
75764       {
75765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75766       };
75767     } catch (Dali::DaliException e) {
75768       {
75769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75770       };
75771     } catch (...) {
75772       {
75773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75774       };
75775     }
75776   }
75777
75778   jresult = new Dali::Actor((const Dali::Actor &)result);
75779   return jresult;
75780 }
75781
75782
75783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75784   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75785   unsigned int arg2 ;
75786   Dali::Actor arg3 ;
75787   Dali::Actor *argp3 ;
75788
75789   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75790   arg2 = (unsigned int)jarg2;
75791   argp3 = (Dali::Actor *)jarg3;
75792   if (!argp3) {
75793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75794     return ;
75795   }
75796   arg3 = *argp3;
75797   {
75798     try {
75799       (arg1)->ItemReleased(arg2,arg3);
75800     } catch (std::out_of_range& e) {
75801       {
75802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75803       };
75804     } catch (std::exception& e) {
75805       {
75806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75807       };
75808     } catch (Dali::DaliException e) {
75809       {
75810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75811       };
75812     } catch (...) {
75813       {
75814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75815       };
75816     }
75817   }
75818
75819 }
75820
75821
75822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75823   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75824   unsigned int arg2 ;
75825   Dali::Actor arg3 ;
75826   Dali::Actor *argp3 ;
75827
75828   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75829   arg2 = (unsigned int)jarg2;
75830   argp3 = (Dali::Actor *)jarg3;
75831   if (!argp3) {
75832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75833     return ;
75834   }
75835   arg3 = *argp3;
75836   {
75837     try {
75838       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75839     } catch (std::out_of_range& e) {
75840       {
75841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75842       };
75843     } catch (std::exception& e) {
75844       {
75845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75846       };
75847     } catch (Dali::DaliException e) {
75848       {
75849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75850       };
75851     } catch (...) {
75852       {
75853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75854       };
75855     }
75856   }
75857
75858 }
75859
75860
75861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75862   void * jresult ;
75863   Dali::Toolkit::ItemFactory *result = 0 ;
75864
75865   {
75866     try {
75867       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75868     } catch (std::out_of_range& e) {
75869       {
75870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75871       };
75872     } catch (std::exception& e) {
75873       {
75874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75875       };
75876     } catch (Dali::DaliException e) {
75877       {
75878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75879       };
75880     } catch (...) {
75881       {
75882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75883       };
75884     }
75885   }
75886
75887   jresult = (void *)result;
75888   return jresult;
75889 }
75890
75891
75892 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) {
75893   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75894   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75895   if (director) {
75896     director->swig_connect_director(callback0, callback1, callback2);
75897   }
75898 }
75899
75900
75901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75902   int jresult ;
75903   int result;
75904
75905   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75906   jresult = (int)result;
75907   return jresult;
75908 }
75909
75910
75911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75912   int jresult ;
75913   int result;
75914
75915   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75916   jresult = (int)result;
75917   return jresult;
75918 }
75919
75920
75921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75922   int jresult ;
75923   int result;
75924
75925   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75926   jresult = (int)result;
75927   return jresult;
75928 }
75929
75930
75931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75932   int jresult ;
75933   int result;
75934
75935   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75936   jresult = (int)result;
75937   return jresult;
75938 }
75939
75940
75941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75942   int jresult ;
75943   int result;
75944
75945   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75946   jresult = (int)result;
75947   return jresult;
75948 }
75949
75950
75951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75952   int jresult ;
75953   int result;
75954
75955   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75956   jresult = (int)result;
75957   return jresult;
75958 }
75959
75960
75961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75962   int jresult ;
75963   int result;
75964
75965   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75966   jresult = (int)result;
75967   return jresult;
75968 }
75969
75970
75971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75972   int jresult ;
75973   int result;
75974
75975   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75976   jresult = (int)result;
75977   return jresult;
75978 }
75979
75980
75981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75982   int jresult ;
75983   int result;
75984
75985   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75986   jresult = (int)result;
75987   return jresult;
75988 }
75989
75990
75991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75992   int jresult ;
75993   int result;
75994
75995   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75996   jresult = (int)result;
75997   return jresult;
75998 }
75999
76000
76001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76002   int jresult ;
76003   int result;
76004
76005   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76006   jresult = (int)result;
76007   return jresult;
76008 }
76009
76010
76011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76012   void * jresult ;
76013   Dali::Toolkit::ItemView::Property *result = 0 ;
76014
76015   {
76016     try {
76017       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76018     } catch (std::out_of_range& e) {
76019       {
76020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76021       };
76022     } catch (std::exception& e) {
76023       {
76024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76025       };
76026     } catch (Dali::DaliException e) {
76027       {
76028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76029       };
76030     } catch (...) {
76031       {
76032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76033       };
76034     }
76035   }
76036
76037   jresult = (void *)result;
76038   return jresult;
76039 }
76040
76041
76042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76043   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76044
76045   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76046   {
76047     try {
76048       delete arg1;
76049     } catch (std::out_of_range& e) {
76050       {
76051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76052       };
76053     } catch (std::exception& e) {
76054       {
76055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76056       };
76057     } catch (Dali::DaliException e) {
76058       {
76059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76060       };
76061     } catch (...) {
76062       {
76063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76064       };
76065     }
76066   }
76067
76068 }
76069
76070
76071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76072   void * jresult ;
76073   Dali::Toolkit::ItemView *result = 0 ;
76074
76075   {
76076     try {
76077       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76078     } catch (std::out_of_range& e) {
76079       {
76080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76081       };
76082     } catch (std::exception& e) {
76083       {
76084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76085       };
76086     } catch (Dali::DaliException e) {
76087       {
76088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76089       };
76090     } catch (...) {
76091       {
76092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76093       };
76094     }
76095   }
76096
76097   jresult = (void *)result;
76098   return jresult;
76099 }
76100
76101
76102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76103   void * jresult ;
76104   Dali::Toolkit::ItemView *arg1 = 0 ;
76105   Dali::Toolkit::ItemView *result = 0 ;
76106
76107   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76108   if (!arg1) {
76109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76110     return 0;
76111   }
76112   {
76113     try {
76114       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76115     } catch (std::out_of_range& e) {
76116       {
76117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76118       };
76119     } catch (std::exception& e) {
76120       {
76121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76122       };
76123     } catch (Dali::DaliException e) {
76124       {
76125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76126       };
76127     } catch (...) {
76128       {
76129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76130       };
76131     }
76132   }
76133
76134   jresult = (void *)result;
76135   return jresult;
76136 }
76137
76138
76139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76140   void * jresult ;
76141   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76142   Dali::Toolkit::ItemView *arg2 = 0 ;
76143   Dali::Toolkit::ItemView *result = 0 ;
76144
76145   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76146   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76147   if (!arg2) {
76148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76149     return 0;
76150   }
76151   {
76152     try {
76153       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76154     } catch (std::out_of_range& e) {
76155       {
76156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76157       };
76158     } catch (std::exception& e) {
76159       {
76160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76161       };
76162     } catch (Dali::DaliException e) {
76163       {
76164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76165       };
76166     } catch (...) {
76167       {
76168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76169       };
76170     }
76171   }
76172
76173   jresult = (void *)result;
76174   return jresult;
76175 }
76176
76177
76178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76179   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76180
76181   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76182   {
76183     try {
76184       delete arg1;
76185     } catch (std::out_of_range& e) {
76186       {
76187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76188       };
76189     } catch (std::exception& e) {
76190       {
76191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76192       };
76193     } catch (Dali::DaliException e) {
76194       {
76195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76196       };
76197     } catch (...) {
76198       {
76199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76200       };
76201     }
76202   }
76203
76204 }
76205
76206
76207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76208   void * jresult ;
76209   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76210   Dali::Toolkit::ItemView result;
76211
76212   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76213   if (!arg1) {
76214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76215     return 0;
76216   }
76217   {
76218     try {
76219       result = Dali::Toolkit::ItemView::New(*arg1);
76220     } catch (std::out_of_range& e) {
76221       {
76222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76223       };
76224     } catch (std::exception& e) {
76225       {
76226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76227       };
76228     } catch (Dali::DaliException e) {
76229       {
76230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76231       };
76232     } catch (...) {
76233       {
76234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76235       };
76236     }
76237   }
76238
76239   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76240   return jresult;
76241 }
76242
76243
76244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76245   void * jresult ;
76246   Dali::BaseHandle arg1 ;
76247   Dali::BaseHandle *argp1 ;
76248   Dali::Toolkit::ItemView result;
76249
76250   argp1 = (Dali::BaseHandle *)jarg1;
76251   if (!argp1) {
76252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76253     return 0;
76254   }
76255   arg1 = *argp1;
76256   {
76257     try {
76258       result = Dali::Toolkit::ItemView::DownCast(arg1);
76259     } catch (std::out_of_range& e) {
76260       {
76261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76262       };
76263     } catch (std::exception& e) {
76264       {
76265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76266       };
76267     } catch (Dali::DaliException e) {
76268       {
76269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76270       };
76271     } catch (...) {
76272       {
76273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76274       };
76275     }
76276   }
76277
76278   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76279   return jresult;
76280 }
76281
76282
76283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76284   unsigned int jresult ;
76285   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76286   unsigned int result;
76287
76288   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76289   {
76290     try {
76291       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76292     } catch (std::out_of_range& e) {
76293       {
76294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76295       };
76296     } catch (std::exception& e) {
76297       {
76298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76299       };
76300     } catch (Dali::DaliException e) {
76301       {
76302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76303       };
76304     } catch (...) {
76305       {
76306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76307       };
76308     }
76309   }
76310
76311   jresult = result;
76312   return jresult;
76313 }
76314
76315
76316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76317   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76318   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76319
76320   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76321   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76322   if (!arg2) {
76323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76324     return ;
76325   }
76326   {
76327     try {
76328       (arg1)->AddLayout(*arg2);
76329     } catch (std::out_of_range& e) {
76330       {
76331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76332       };
76333     } catch (std::exception& e) {
76334       {
76335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76336       };
76337     } catch (Dali::DaliException e) {
76338       {
76339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76340       };
76341     } catch (...) {
76342       {
76343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76344       };
76345     }
76346   }
76347
76348 }
76349
76350
76351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76352   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76353   unsigned int arg2 ;
76354
76355   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76356   arg2 = (unsigned int)jarg2;
76357   {
76358     try {
76359       (arg1)->RemoveLayout(arg2);
76360     } catch (std::out_of_range& e) {
76361       {
76362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76363       };
76364     } catch (std::exception& e) {
76365       {
76366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76367       };
76368     } catch (Dali::DaliException e) {
76369       {
76370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76371       };
76372     } catch (...) {
76373       {
76374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76375       };
76376     }
76377   }
76378
76379 }
76380
76381
76382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76383   void * jresult ;
76384   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76385   unsigned int arg2 ;
76386   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76387
76388   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76389   arg2 = (unsigned int)jarg2;
76390   {
76391     try {
76392       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76393     } catch (std::out_of_range& e) {
76394       {
76395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76396       };
76397     } catch (std::exception& e) {
76398       {
76399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76400       };
76401     } catch (Dali::DaliException e) {
76402       {
76403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76404       };
76405     } catch (...) {
76406       {
76407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76408       };
76409     }
76410   }
76411
76412   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76413   return jresult;
76414 }
76415
76416
76417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76418   void * jresult ;
76419   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76420   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76421
76422   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76423   {
76424     try {
76425       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76426     } catch (std::out_of_range& e) {
76427       {
76428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76429       };
76430     } catch (std::exception& e) {
76431       {
76432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76433       };
76434     } catch (Dali::DaliException e) {
76435       {
76436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76437       };
76438     } catch (...) {
76439       {
76440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76441       };
76442     }
76443   }
76444
76445   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76446   return jresult;
76447 }
76448
76449
76450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76451   float jresult ;
76452   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76453   Dali::Toolkit::ItemId arg2 ;
76454   float result;
76455
76456   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76457   arg2 = (Dali::Toolkit::ItemId)jarg2;
76458   {
76459     try {
76460       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76461     } catch (std::out_of_range& e) {
76462       {
76463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76464       };
76465     } catch (std::exception& e) {
76466       {
76467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76468       };
76469     } catch (Dali::DaliException e) {
76470       {
76471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76472       };
76473     } catch (...) {
76474       {
76475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76476       };
76477     }
76478   }
76479
76480   jresult = result;
76481   return jresult;
76482 }
76483
76484
76485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76486   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76487   unsigned int arg2 ;
76488   Dali::Vector3 arg3 ;
76489   float arg4 ;
76490   Dali::Vector3 *argp3 ;
76491
76492   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76493   arg2 = (unsigned int)jarg2;
76494   argp3 = (Dali::Vector3 *)jarg3;
76495   if (!argp3) {
76496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76497     return ;
76498   }
76499   arg3 = *argp3;
76500   arg4 = (float)jarg4;
76501   {
76502     try {
76503       (arg1)->ActivateLayout(arg2,arg3,arg4);
76504     } catch (std::out_of_range& e) {
76505       {
76506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76507       };
76508     } catch (std::exception& e) {
76509       {
76510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76511       };
76512     } catch (Dali::DaliException e) {
76513       {
76514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76515       };
76516     } catch (...) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76519       };
76520     }
76521   }
76522
76523 }
76524
76525
76526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76527   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76528
76529   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76530   {
76531     try {
76532       (arg1)->DeactivateCurrentLayout();
76533     } catch (std::out_of_range& e) {
76534       {
76535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76536       };
76537     } catch (std::exception& e) {
76538       {
76539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76540       };
76541     } catch (Dali::DaliException e) {
76542       {
76543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76544       };
76545     } catch (...) {
76546       {
76547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76548       };
76549     }
76550   }
76551
76552 }
76553
76554
76555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76556   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76557   float arg2 ;
76558
76559   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76560   arg2 = (float)jarg2;
76561   {
76562     try {
76563       (arg1)->SetMinimumSwipeSpeed(arg2);
76564     } catch (std::out_of_range& e) {
76565       {
76566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76567       };
76568     } catch (std::exception& e) {
76569       {
76570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76571       };
76572     } catch (Dali::DaliException e) {
76573       {
76574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76575       };
76576     } catch (...) {
76577       {
76578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76579       };
76580     }
76581   }
76582
76583 }
76584
76585
76586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76587   float jresult ;
76588   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76589   float result;
76590
76591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76592   {
76593     try {
76594       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76595     } catch (std::out_of_range& e) {
76596       {
76597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76598       };
76599     } catch (std::exception& e) {
76600       {
76601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76602       };
76603     } catch (Dali::DaliException e) {
76604       {
76605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76606       };
76607     } catch (...) {
76608       {
76609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76610       };
76611     }
76612   }
76613
76614   jresult = result;
76615   return jresult;
76616 }
76617
76618
76619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76620   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76621   float arg2 ;
76622
76623   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76624   arg2 = (float)jarg2;
76625   {
76626     try {
76627       (arg1)->SetMinimumSwipeDistance(arg2);
76628     } catch (std::out_of_range& e) {
76629       {
76630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76631       };
76632     } catch (std::exception& e) {
76633       {
76634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76635       };
76636     } catch (Dali::DaliException e) {
76637       {
76638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76639       };
76640     } catch (...) {
76641       {
76642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76643       };
76644     }
76645   }
76646
76647 }
76648
76649
76650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76651   float jresult ;
76652   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76653   float result;
76654
76655   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76656   {
76657     try {
76658       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76659     } catch (std::out_of_range& e) {
76660       {
76661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76662       };
76663     } catch (std::exception& e) {
76664       {
76665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76666       };
76667     } catch (Dali::DaliException e) {
76668       {
76669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76670       };
76671     } catch (...) {
76672       {
76673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76674       };
76675     }
76676   }
76677
76678   jresult = result;
76679   return jresult;
76680 }
76681
76682
76683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76684   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76685   float arg2 ;
76686
76687   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76688   arg2 = (float)jarg2;
76689   {
76690     try {
76691       (arg1)->SetWheelScrollDistanceStep(arg2);
76692     } catch (std::out_of_range& e) {
76693       {
76694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76695       };
76696     } catch (std::exception& e) {
76697       {
76698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76699       };
76700     } catch (Dali::DaliException e) {
76701       {
76702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76703       };
76704     } catch (...) {
76705       {
76706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76707       };
76708     }
76709   }
76710
76711 }
76712
76713
76714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76715   float jresult ;
76716   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76717   float result;
76718
76719   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76720   {
76721     try {
76722       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76723     } catch (std::out_of_range& e) {
76724       {
76725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76726       };
76727     } catch (std::exception& e) {
76728       {
76729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76730       };
76731     } catch (Dali::DaliException e) {
76732       {
76733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76734       };
76735     } catch (...) {
76736       {
76737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76738       };
76739     }
76740   }
76741
76742   jresult = result;
76743   return jresult;
76744 }
76745
76746
76747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76748   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76749   bool arg2 ;
76750
76751   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76752   arg2 = jarg2 ? true : false;
76753   {
76754     try {
76755       (arg1)->SetAnchoring(arg2);
76756     } catch (std::out_of_range& e) {
76757       {
76758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76759       };
76760     } catch (std::exception& e) {
76761       {
76762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76763       };
76764     } catch (Dali::DaliException e) {
76765       {
76766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76767       };
76768     } catch (...) {
76769       {
76770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76771       };
76772     }
76773   }
76774
76775 }
76776
76777 //// ========================= end of part 3 =============================
76778
76779 //// ========================== start part 4 ===============================
76780
76781
76782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76783   unsigned int jresult ;
76784   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76785   bool result;
76786
76787   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76788   {
76789     try {
76790       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76791     } catch (std::out_of_range& e) {
76792       {
76793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76794       };
76795     } catch (std::exception& e) {
76796       {
76797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76798       };
76799     } catch (Dali::DaliException e) {
76800       {
76801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76802       };
76803     } catch (...) {
76804       {
76805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76806       };
76807     }
76808   }
76809
76810   jresult = result;
76811   return jresult;
76812 }
76813
76814
76815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76816   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76817   float arg2 ;
76818
76819   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76820   arg2 = (float)jarg2;
76821   {
76822     try {
76823       (arg1)->SetAnchoringDuration(arg2);
76824     } catch (std::out_of_range& e) {
76825       {
76826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76827       };
76828     } catch (std::exception& e) {
76829       {
76830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76831       };
76832     } catch (Dali::DaliException e) {
76833       {
76834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76835       };
76836     } catch (...) {
76837       {
76838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76839       };
76840     }
76841   }
76842
76843 }
76844
76845
76846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76847   float jresult ;
76848   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76849   float result;
76850
76851   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76852   {
76853     try {
76854       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76855     } catch (std::out_of_range& e) {
76856       {
76857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76858       };
76859     } catch (std::exception& e) {
76860       {
76861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76862       };
76863     } catch (Dali::DaliException e) {
76864       {
76865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76866       };
76867     } catch (...) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76870       };
76871     }
76872   }
76873
76874   jresult = result;
76875   return jresult;
76876 }
76877
76878
76879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76880   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76881   Dali::Toolkit::ItemId arg2 ;
76882   float arg3 ;
76883
76884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76885   arg2 = (Dali::Toolkit::ItemId)jarg2;
76886   arg3 = (float)jarg3;
76887   {
76888     try {
76889       (arg1)->ScrollToItem(arg2,arg3);
76890     } catch (std::out_of_range& e) {
76891       {
76892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76893       };
76894     } catch (std::exception& e) {
76895       {
76896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76897       };
76898     } catch (Dali::DaliException e) {
76899       {
76900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76901       };
76902     } catch (...) {
76903       {
76904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76905       };
76906     }
76907   }
76908
76909 }
76910
76911
76912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76913   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76914   float arg2 ;
76915
76916   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76917   arg2 = (float)jarg2;
76918   {
76919     try {
76920       (arg1)->SetRefreshInterval(arg2);
76921     } catch (std::out_of_range& e) {
76922       {
76923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76924       };
76925     } catch (std::exception& e) {
76926       {
76927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76928       };
76929     } catch (Dali::DaliException e) {
76930       {
76931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76932       };
76933     } catch (...) {
76934       {
76935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76936       };
76937     }
76938   }
76939
76940 }
76941
76942
76943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76944   float jresult ;
76945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76946   float result;
76947
76948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76949   {
76950     try {
76951       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76952     } catch (std::out_of_range& e) {
76953       {
76954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76955       };
76956     } catch (std::exception& e) {
76957       {
76958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76959       };
76960     } catch (Dali::DaliException e) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76963       };
76964     } catch (...) {
76965       {
76966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76967       };
76968     }
76969   }
76970
76971   jresult = result;
76972   return jresult;
76973 }
76974
76975
76976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76978
76979   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76980   {
76981     try {
76982       (arg1)->Refresh();
76983     } catch (std::out_of_range& e) {
76984       {
76985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76986       };
76987     } catch (std::exception& e) {
76988       {
76989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76990       };
76991     } catch (Dali::DaliException e) {
76992       {
76993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76994       };
76995     } catch (...) {
76996       {
76997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76998       };
76999     }
77000   }
77001
77002 }
77003
77004
77005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77006   void * jresult ;
77007   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77008   Dali::Toolkit::ItemId arg2 ;
77009   Dali::Actor result;
77010
77011   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77012   arg2 = (Dali::Toolkit::ItemId)jarg2;
77013   {
77014     try {
77015       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77016     } catch (std::out_of_range& e) {
77017       {
77018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77019       };
77020     } catch (std::exception& e) {
77021       {
77022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77023       };
77024     } catch (Dali::DaliException e) {
77025       {
77026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77027       };
77028     } catch (...) {
77029       {
77030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77031       };
77032     }
77033   }
77034
77035   jresult = new Dali::Actor((const Dali::Actor &)result);
77036   return jresult;
77037 }
77038
77039
77040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77041   unsigned int jresult ;
77042   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77043   Dali::Actor arg2 ;
77044   Dali::Actor *argp2 ;
77045   Dali::Toolkit::ItemId result;
77046
77047   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77048   argp2 = (Dali::Actor *)jarg2;
77049   if (!argp2) {
77050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77051     return 0;
77052   }
77053   arg2 = *argp2;
77054   {
77055     try {
77056       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77057     } catch (std::out_of_range& e) {
77058       {
77059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77060       };
77061     } catch (std::exception& e) {
77062       {
77063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77064       };
77065     } catch (Dali::DaliException e) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77068       };
77069     } catch (...) {
77070       {
77071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77072       };
77073     }
77074   }
77075
77076   jresult = result;
77077   return jresult;
77078 }
77079
77080
77081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77082   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77083   Dali::Toolkit::Item arg2 ;
77084   float arg3 ;
77085   Dali::Toolkit::Item *argp2 ;
77086
77087   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77088   argp2 = (Dali::Toolkit::Item *)jarg2;
77089   if (!argp2) {
77090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77091     return ;
77092   }
77093   arg2 = *argp2;
77094   arg3 = (float)jarg3;
77095   {
77096     try {
77097       (arg1)->InsertItem(arg2,arg3);
77098     } catch (std::out_of_range& e) {
77099       {
77100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77101       };
77102     } catch (std::exception& e) {
77103       {
77104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77105       };
77106     } catch (Dali::DaliException e) {
77107       {
77108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77109       };
77110     } catch (...) {
77111       {
77112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77113       };
77114     }
77115   }
77116
77117 }
77118
77119
77120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77121   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77122   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77123   float arg3 ;
77124
77125   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77126   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77127   if (!arg2) {
77128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77129     return ;
77130   }
77131   arg3 = (float)jarg3;
77132   {
77133     try {
77134       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77135     } catch (std::out_of_range& e) {
77136       {
77137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77138       };
77139     } catch (std::exception& e) {
77140       {
77141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77142       };
77143     } catch (Dali::DaliException e) {
77144       {
77145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77150       };
77151     }
77152   }
77153
77154 }
77155
77156
77157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77158   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77159   Dali::Toolkit::ItemId arg2 ;
77160   float arg3 ;
77161
77162   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77163   arg2 = (Dali::Toolkit::ItemId)jarg2;
77164   arg3 = (float)jarg3;
77165   {
77166     try {
77167       (arg1)->RemoveItem(arg2,arg3);
77168     } catch (std::out_of_range& e) {
77169       {
77170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77171       };
77172     } catch (std::exception& e) {
77173       {
77174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77175       };
77176     } catch (Dali::DaliException e) {
77177       {
77178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77179       };
77180     } catch (...) {
77181       {
77182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77183       };
77184     }
77185   }
77186
77187 }
77188
77189
77190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77191   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77192   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77193   float arg3 ;
77194
77195   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77196   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77197   if (!arg2) {
77198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77199     return ;
77200   }
77201   arg3 = (float)jarg3;
77202   {
77203     try {
77204       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77205     } catch (std::out_of_range& e) {
77206       {
77207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77208       };
77209     } catch (std::exception& e) {
77210       {
77211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77212       };
77213     } catch (Dali::DaliException e) {
77214       {
77215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77216       };
77217     } catch (...) {
77218       {
77219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77220       };
77221     }
77222   }
77223
77224 }
77225
77226
77227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77228   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77229   Dali::Toolkit::Item arg2 ;
77230   float arg3 ;
77231   Dali::Toolkit::Item *argp2 ;
77232
77233   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77234   argp2 = (Dali::Toolkit::Item *)jarg2;
77235   if (!argp2) {
77236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77237     return ;
77238   }
77239   arg2 = *argp2;
77240   arg3 = (float)jarg3;
77241   {
77242     try {
77243       (arg1)->ReplaceItem(arg2,arg3);
77244     } catch (std::out_of_range& e) {
77245       {
77246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77247       };
77248     } catch (std::exception& e) {
77249       {
77250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77251       };
77252     } catch (Dali::DaliException e) {
77253       {
77254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77255       };
77256     } catch (...) {
77257       {
77258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77259       };
77260     }
77261   }
77262
77263 }
77264
77265
77266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77267   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77268   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77269   float arg3 ;
77270
77271   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77272   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77273   if (!arg2) {
77274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77275     return ;
77276   }
77277   arg3 = (float)jarg3;
77278   {
77279     try {
77280       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77281     } catch (std::out_of_range& e) {
77282       {
77283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77284       };
77285     } catch (std::exception& e) {
77286       {
77287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77288       };
77289     } catch (Dali::DaliException e) {
77290       {
77291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77292       };
77293     } catch (...) {
77294       {
77295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77296       };
77297     }
77298   }
77299
77300 }
77301
77302
77303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77304   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77305   Dali::Vector3 *arg2 = 0 ;
77306
77307   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77308   arg2 = (Dali::Vector3 *)jarg2;
77309   if (!arg2) {
77310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77311     return ;
77312   }
77313   {
77314     try {
77315       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77316     } catch (std::out_of_range& e) {
77317       {
77318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77319       };
77320     } catch (std::exception& e) {
77321       {
77322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77323       };
77324     } catch (Dali::DaliException e) {
77325       {
77326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77327       };
77328     } catch (...) {
77329       {
77330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77331       };
77332     }
77333   }
77334
77335 }
77336
77337
77338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77339   void * jresult ;
77340   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77341   Dali::Vector3 result;
77342
77343   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77344   {
77345     try {
77346       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77347     } catch (std::out_of_range& e) {
77348       {
77349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77350       };
77351     } catch (std::exception& e) {
77352       {
77353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77354       };
77355     } catch (Dali::DaliException e) {
77356       {
77357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77358       };
77359     } catch (...) {
77360       {
77361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77362       };
77363     }
77364   }
77365
77366   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77367   return jresult;
77368 }
77369
77370
77371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77372   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77373   Dali::Vector3 *arg2 = 0 ;
77374
77375   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77376   arg2 = (Dali::Vector3 *)jarg2;
77377   if (!arg2) {
77378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77379     return ;
77380   }
77381   {
77382     try {
77383       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77384     } catch (std::out_of_range& e) {
77385       {
77386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77387       };
77388     } catch (std::exception& e) {
77389       {
77390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77391       };
77392     } catch (Dali::DaliException e) {
77393       {
77394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77395       };
77396     } catch (...) {
77397       {
77398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77399       };
77400     }
77401   }
77402
77403 }
77404
77405
77406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77407   void * jresult ;
77408   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77409   Dali::Vector3 result;
77410
77411   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77412   {
77413     try {
77414       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77415     } catch (std::out_of_range& e) {
77416       {
77417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77418       };
77419     } catch (std::exception& e) {
77420       {
77421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77422       };
77423     } catch (Dali::DaliException e) {
77424       {
77425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77426       };
77427     } catch (...) {
77428       {
77429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77430       };
77431     }
77432   }
77433
77434   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77435   return jresult;
77436 }
77437
77438
77439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77441   Dali::Toolkit::ItemRange *arg2 = 0 ;
77442
77443   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77444   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77445   if (!arg2) {
77446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77447     return ;
77448   }
77449   {
77450     try {
77451       (arg1)->GetItemsRange(*arg2);
77452     } catch (std::out_of_range& e) {
77453       {
77454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77455       };
77456     } catch (std::exception& e) {
77457       {
77458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77459       };
77460     } catch (Dali::DaliException e) {
77461       {
77462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77463       };
77464     } catch (...) {
77465       {
77466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77467       };
77468     }
77469   }
77470
77471 }
77472
77473
77474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77475   void * jresult ;
77476   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77477   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77478
77479   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77480   {
77481     try {
77482       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77483     } catch (std::out_of_range& e) {
77484       {
77485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77486       };
77487     } catch (std::exception& e) {
77488       {
77489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77490       };
77491     } catch (Dali::DaliException e) {
77492       {
77493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77494       };
77495     } catch (...) {
77496       {
77497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77498       };
77499     }
77500   }
77501
77502   jresult = (void *)result;
77503   return jresult;
77504 }
77505
77506
77507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77508   Dali::Vector3 *arg1 = 0 ;
77509   PropertyInputContainer *arg2 = 0 ;
77510
77511   arg1 = (Dali::Vector3 *)jarg1;
77512   if (!arg1) {
77513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77514     return ;
77515   }
77516   arg2 = (PropertyInputContainer *)jarg2;
77517   if (!arg2) {
77518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77519     return ;
77520   }
77521   {
77522     try {
77523       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77524     } catch (std::out_of_range& e) {
77525       {
77526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77527       };
77528     } catch (std::exception& e) {
77529       {
77530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77531       };
77532     } catch (Dali::DaliException e) {
77533       {
77534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77535       };
77536     } catch (...) {
77537       {
77538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77539       };
77540     }
77541   }
77542
77543 }
77544
77545
77546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77547   Dali::Vector3 *arg1 = 0 ;
77548   PropertyInputContainer *arg2 = 0 ;
77549
77550   arg1 = (Dali::Vector3 *)jarg1;
77551   if (!arg1) {
77552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77553     return ;
77554   }
77555   arg2 = (PropertyInputContainer *)jarg2;
77556   if (!arg2) {
77557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77558     return ;
77559   }
77560   {
77561     try {
77562       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77563     } catch (std::out_of_range& e) {
77564       {
77565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77566       };
77567     } catch (std::exception& e) {
77568       {
77569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77570       };
77571     } catch (Dali::DaliException e) {
77572       {
77573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77574       };
77575     } catch (...) {
77576       {
77577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77578       };
77579     }
77580   }
77581
77582 }
77583
77584
77585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77586   void * jresult ;
77587   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77588
77589   {
77590     try {
77591       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77592     } catch (std::out_of_range& e) {
77593       {
77594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77595       };
77596     } catch (std::exception& e) {
77597       {
77598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77599       };
77600     } catch (Dali::DaliException e) {
77601       {
77602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77603       };
77604     } catch (...) {
77605       {
77606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77607       };
77608     }
77609   }
77610
77611   jresult = (void *)result;
77612   return jresult;
77613 }
77614
77615
77616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77617   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77618
77619   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77620   {
77621     try {
77622       delete arg1;
77623     } catch (std::out_of_range& e) {
77624       {
77625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77626       };
77627     } catch (std::exception& e) {
77628       {
77629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77630       };
77631     } catch (Dali::DaliException e) {
77632       {
77633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77634       };
77635     } catch (...) {
77636       {
77637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77638       };
77639     }
77640   }
77641
77642 }
77643
77644
77645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77646   void * jresult ;
77647   Dali::Path arg1 ;
77648   Dali::Vector3 *arg2 = 0 ;
77649   Dali::Property::Index arg3 ;
77650   Dali::Vector3 *arg4 = 0 ;
77651   unsigned int arg5 ;
77652   Dali::Path *argp1 ;
77653   Dali::Toolkit::ScrollViewPagePathEffect result;
77654
77655   argp1 = (Dali::Path *)jarg1;
77656   if (!argp1) {
77657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77658     return 0;
77659   }
77660   arg1 = *argp1;
77661   arg2 = (Dali::Vector3 *)jarg2;
77662   if (!arg2) {
77663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77664     return 0;
77665   }
77666   arg3 = (Dali::Property::Index)jarg3;
77667   arg4 = (Dali::Vector3 *)jarg4;
77668   if (!arg4) {
77669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77670     return 0;
77671   }
77672   arg5 = (unsigned int)jarg5;
77673   {
77674     try {
77675       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77676     } catch (std::out_of_range& e) {
77677       {
77678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77679       };
77680     } catch (std::exception& e) {
77681       {
77682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77683       };
77684     } catch (Dali::DaliException e) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77687       };
77688     } catch (...) {
77689       {
77690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77691       };
77692     }
77693   }
77694
77695   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77696   return jresult;
77697 }
77698
77699
77700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77701   void * jresult ;
77702   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77703
77704   {
77705     try {
77706       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77707     } catch (std::out_of_range& e) {
77708       {
77709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77710       };
77711     } catch (std::exception& e) {
77712       {
77713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77714       };
77715     } catch (Dali::DaliException e) {
77716       {
77717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77718       };
77719     } catch (...) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77722       };
77723     }
77724   }
77725
77726   jresult = (void *)result;
77727   return jresult;
77728 }
77729
77730
77731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77732   void * jresult ;
77733   Dali::BaseHandle arg1 ;
77734   Dali::BaseHandle *argp1 ;
77735   Dali::Toolkit::ScrollViewPagePathEffect result;
77736
77737   argp1 = (Dali::BaseHandle *)jarg1;
77738   if (!argp1) {
77739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77740     return 0;
77741   }
77742   arg1 = *argp1;
77743   {
77744     try {
77745       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77746     } catch (std::out_of_range& e) {
77747       {
77748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77749       };
77750     } catch (std::exception& e) {
77751       {
77752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77753       };
77754     } catch (Dali::DaliException e) {
77755       {
77756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77757       };
77758     } catch (...) {
77759       {
77760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77761       };
77762     }
77763   }
77764
77765   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77771   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77772   Dali::Actor arg2 ;
77773   unsigned int arg3 ;
77774   Dali::Actor *argp2 ;
77775
77776   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77777   argp2 = (Dali::Actor *)jarg2;
77778   if (!argp2) {
77779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77780     return ;
77781   }
77782   arg2 = *argp2;
77783   arg3 = (unsigned int)jarg3;
77784   {
77785     try {
77786       (arg1)->ApplyToPage(arg2,arg3);
77787     } catch (std::out_of_range& e) {
77788       {
77789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77790       };
77791     } catch (std::exception& e) {
77792       {
77793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77794       };
77795     } catch (Dali::DaliException e) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77798       };
77799     } catch (...) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77802       };
77803     }
77804   }
77805
77806 }
77807
77808
77809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77810   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77811
77812   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77813   {
77814     try {
77815       delete arg1;
77816     } catch (std::out_of_range& e) {
77817       {
77818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77819       };
77820     } catch (std::exception& e) {
77821       {
77822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77823       };
77824     } catch (Dali::DaliException e) {
77825       {
77826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77827       };
77828     } catch (...) {
77829       {
77830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77831       };
77832     }
77833   }
77834
77835 }
77836
77837
77838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77839   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77840   Dali::Toolkit::ClampState arg2 ;
77841
77842   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77843   arg2 = (Dali::Toolkit::ClampState)jarg2;
77844   if (arg1) (arg1)->x = arg2;
77845 }
77846
77847
77848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77849   int jresult ;
77850   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77851   Dali::Toolkit::ClampState result;
77852
77853   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77854   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77855   jresult = (int)result;
77856   return jresult;
77857 }
77858
77859
77860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77861   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77862   Dali::Toolkit::ClampState arg2 ;
77863
77864   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77865   arg2 = (Dali::Toolkit::ClampState)jarg2;
77866   if (arg1) (arg1)->y = arg2;
77867 }
77868
77869
77870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77871   int jresult ;
77872   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77873   Dali::Toolkit::ClampState result;
77874
77875   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77876   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77877   jresult = (int)result;
77878   return jresult;
77879 }
77880
77881
77882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77883   void * jresult ;
77884   Dali::Toolkit::ClampState2D *result = 0 ;
77885
77886   {
77887     try {
77888       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77889     } catch (std::out_of_range& e) {
77890       {
77891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77892       };
77893     } catch (std::exception& e) {
77894       {
77895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77896       };
77897     } catch (Dali::DaliException e) {
77898       {
77899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77900       };
77901     } catch (...) {
77902       {
77903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77904       };
77905     }
77906   }
77907
77908   jresult = (void *)result;
77909   return jresult;
77910 }
77911
77912
77913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77914   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77915
77916   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77917   {
77918     try {
77919       delete arg1;
77920     } catch (std::out_of_range& e) {
77921       {
77922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77923       };
77924     } catch (std::exception& e) {
77925       {
77926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77927       };
77928     } catch (Dali::DaliException e) {
77929       {
77930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77931       };
77932     } catch (...) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77935       };
77936     }
77937   }
77938
77939 }
77940
77941
77942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77943   void * jresult ;
77944   float arg1 ;
77945   float arg2 ;
77946   bool arg3 ;
77947   Dali::Toolkit::RulerDomain *result = 0 ;
77948
77949   arg1 = (float)jarg1;
77950   arg2 = (float)jarg2;
77951   arg3 = jarg3 ? true : false;
77952   {
77953     try {
77954       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77955     } catch (std::out_of_range& e) {
77956       {
77957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77958       };
77959     } catch (std::exception& e) {
77960       {
77961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77962       };
77963     } catch (Dali::DaliException e) {
77964       {
77965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77966       };
77967     } catch (...) {
77968       {
77969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77970       };
77971     }
77972   }
77973
77974   jresult = (void *)result;
77975   return jresult;
77976 }
77977
77978
77979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77980   void * jresult ;
77981   float arg1 ;
77982   float arg2 ;
77983   Dali::Toolkit::RulerDomain *result = 0 ;
77984
77985   arg1 = (float)jarg1;
77986   arg2 = (float)jarg2;
77987   {
77988     try {
77989       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77990     } catch (std::out_of_range& e) {
77991       {
77992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77993       };
77994     } catch (std::exception& e) {
77995       {
77996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77997       };
77998     } catch (Dali::DaliException e) {
77999       {
78000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78001       };
78002     } catch (...) {
78003       {
78004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78005       };
78006     }
78007   }
78008
78009   jresult = (void *)result;
78010   return jresult;
78011 }
78012
78013
78014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78015   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78016   float arg2 ;
78017
78018   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78019   arg2 = (float)jarg2;
78020   if (arg1) (arg1)->min = arg2;
78021 }
78022
78023
78024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78025   float jresult ;
78026   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78027   float result;
78028
78029   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78030   result = (float) ((arg1)->min);
78031   jresult = result;
78032   return jresult;
78033 }
78034
78035
78036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78037   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78038   float arg2 ;
78039
78040   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78041   arg2 = (float)jarg2;
78042   if (arg1) (arg1)->max = arg2;
78043 }
78044
78045
78046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78047   float jresult ;
78048   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78049   float result;
78050
78051   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78052   result = (float) ((arg1)->max);
78053   jresult = result;
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78059   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78060   bool arg2 ;
78061
78062   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78063   arg2 = jarg2 ? true : false;
78064   if (arg1) (arg1)->enabled = arg2;
78065 }
78066
78067
78068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78069   unsigned int jresult ;
78070   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78071   bool result;
78072
78073   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78074   result = (bool) ((arg1)->enabled);
78075   jresult = result;
78076   return jresult;
78077 }
78078
78079
78080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78081   float jresult ;
78082   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78083   float arg2 ;
78084   float arg3 ;
78085   float arg4 ;
78086   float result;
78087
78088   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78089   arg2 = (float)jarg2;
78090   arg3 = (float)jarg3;
78091   arg4 = (float)jarg4;
78092   {
78093     try {
78094       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78095     } catch (std::out_of_range& e) {
78096       {
78097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78098       };
78099     } catch (std::exception& e) {
78100       {
78101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78102       };
78103     } catch (Dali::DaliException e) {
78104       {
78105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78106       };
78107     } catch (...) {
78108       {
78109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78110       };
78111     }
78112   }
78113
78114   jresult = result;
78115   return jresult;
78116 }
78117
78118
78119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78120   float jresult ;
78121   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78122   float arg2 ;
78123   float arg3 ;
78124   float result;
78125
78126   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78127   arg2 = (float)jarg2;
78128   arg3 = (float)jarg3;
78129   {
78130     try {
78131       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78132     } catch (std::out_of_range& e) {
78133       {
78134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78135       };
78136     } catch (std::exception& e) {
78137       {
78138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78139       };
78140     } catch (Dali::DaliException e) {
78141       {
78142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78143       };
78144     } catch (...) {
78145       {
78146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78147       };
78148     }
78149   }
78150
78151   jresult = result;
78152   return jresult;
78153 }
78154
78155
78156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78157   float jresult ;
78158   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78159   float arg2 ;
78160   float result;
78161
78162   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78163   arg2 = (float)jarg2;
78164   {
78165     try {
78166       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78167     } catch (std::out_of_range& e) {
78168       {
78169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78170       };
78171     } catch (std::exception& e) {
78172       {
78173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78174       };
78175     } catch (Dali::DaliException e) {
78176       {
78177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78178       };
78179     } catch (...) {
78180       {
78181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78182       };
78183     }
78184   }
78185
78186   jresult = result;
78187   return jresult;
78188 }
78189
78190
78191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78192   float jresult ;
78193   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78194   float arg2 ;
78195   float arg3 ;
78196   float arg4 ;
78197   Dali::Toolkit::ClampState *arg5 = 0 ;
78198   float result;
78199
78200   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78201   arg2 = (float)jarg2;
78202   arg3 = (float)jarg3;
78203   arg4 = (float)jarg4;
78204   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78205   if (!arg5) {
78206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78207     return 0;
78208   }
78209   {
78210     try {
78211       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78212     } catch (std::out_of_range& e) {
78213       {
78214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78215       };
78216     } catch (std::exception& e) {
78217       {
78218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78219       };
78220     } catch (Dali::DaliException e) {
78221       {
78222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78223       };
78224     } catch (...) {
78225       {
78226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78227       };
78228     }
78229   }
78230
78231   jresult = result;
78232   return jresult;
78233 }
78234
78235
78236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78237   float jresult ;
78238   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78239   float result;
78240
78241   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78242   {
78243     try {
78244       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78245     } catch (std::out_of_range& e) {
78246       {
78247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78248       };
78249     } catch (std::exception& e) {
78250       {
78251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78252       };
78253     } catch (Dali::DaliException e) {
78254       {
78255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78256       };
78257     } catch (...) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78260       };
78261     }
78262   }
78263
78264   jresult = result;
78265   return jresult;
78266 }
78267
78268
78269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78270   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78271
78272   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78273   {
78274     try {
78275       delete arg1;
78276     } catch (std::out_of_range& e) {
78277       {
78278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78279       };
78280     } catch (std::exception& e) {
78281       {
78282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78283       };
78284     } catch (Dali::DaliException e) {
78285       {
78286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78287       };
78288     } catch (...) {
78289       {
78290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78291       };
78292     }
78293   }
78294
78295 }
78296
78297
78298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78299   float jresult ;
78300   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78301   float arg2 ;
78302   float arg3 ;
78303   float result;
78304
78305   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78306   arg2 = (float)jarg2;
78307   arg3 = (float)jarg3;
78308   {
78309     try {
78310       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78311     } catch (std::out_of_range& e) {
78312       {
78313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78314       };
78315     } catch (std::exception& e) {
78316       {
78317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78318       };
78319     } catch (Dali::DaliException e) {
78320       {
78321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78322       };
78323     } catch (...) {
78324       {
78325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78326       };
78327     }
78328   }
78329
78330   jresult = result;
78331   return jresult;
78332 }
78333
78334
78335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78336   float jresult ;
78337   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78338   float arg2 ;
78339   float result;
78340
78341   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78342   arg2 = (float)jarg2;
78343   {
78344     try {
78345       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78346     } catch (std::out_of_range& e) {
78347       {
78348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78349       };
78350     } catch (std::exception& e) {
78351       {
78352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78353       };
78354     } catch (Dali::DaliException e) {
78355       {
78356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78357       };
78358     } catch (...) {
78359       {
78360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78361       };
78362     }
78363   }
78364
78365   jresult = result;
78366   return jresult;
78367 }
78368
78369
78370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78371   float jresult ;
78372   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78373   unsigned int arg2 ;
78374   unsigned int *arg3 = 0 ;
78375   bool arg4 ;
78376   float result;
78377
78378   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78379   arg2 = (unsigned int)jarg2;
78380   arg3 = (unsigned int *)jarg3;
78381   arg4 = jarg4 ? true : false;
78382   {
78383     try {
78384       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78385     } catch (std::out_of_range& e) {
78386       {
78387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78388       };
78389     } catch (std::exception& e) {
78390       {
78391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78392       };
78393     } catch (Dali::DaliException e) {
78394       {
78395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78396       };
78397     } catch (...) {
78398       {
78399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78400       };
78401     }
78402   }
78403
78404   jresult = result;
78405   return jresult;
78406 }
78407
78408
78409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78410   unsigned int jresult ;
78411   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78412   float arg2 ;
78413   bool arg3 ;
78414   unsigned int result;
78415
78416   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78417   arg2 = (float)jarg2;
78418   arg3 = jarg3 ? true : false;
78419   {
78420     try {
78421       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78422     } catch (std::out_of_range& e) {
78423       {
78424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78425       };
78426     } catch (std::exception& e) {
78427       {
78428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78429       };
78430     } catch (Dali::DaliException e) {
78431       {
78432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78433       };
78434     } catch (...) {
78435       {
78436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78437       };
78438     }
78439   }
78440
78441   jresult = result;
78442   return jresult;
78443 }
78444
78445
78446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78447   unsigned int jresult ;
78448   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78449   unsigned int result;
78450
78451   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78452   {
78453     try {
78454       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78455     } catch (std::out_of_range& e) {
78456       {
78457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78458       };
78459     } catch (std::exception& e) {
78460       {
78461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78462       };
78463     } catch (Dali::DaliException e) {
78464       {
78465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78466       };
78467     } catch (...) {
78468       {
78469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78470       };
78471     }
78472   }
78473
78474   jresult = result;
78475   return jresult;
78476 }
78477
78478
78479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78480   int jresult ;
78481   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78482   Dali::Toolkit::Ruler::RulerType result;
78483
78484   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78485   {
78486     try {
78487       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78488     } catch (std::out_of_range& e) {
78489       {
78490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78491       };
78492     } catch (std::exception& e) {
78493       {
78494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78495       };
78496     } catch (Dali::DaliException e) {
78497       {
78498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78499       };
78500     } catch (...) {
78501       {
78502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78503       };
78504     }
78505   }
78506
78507   jresult = (int)result;
78508   return jresult;
78509 }
78510
78511
78512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78513   unsigned int jresult ;
78514   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78515   bool result;
78516
78517   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78518   {
78519     try {
78520       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78521     } catch (std::out_of_range& e) {
78522       {
78523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78524       };
78525     } catch (std::exception& e) {
78526       {
78527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78528       };
78529     } catch (Dali::DaliException e) {
78530       {
78531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78532       };
78533     } catch (...) {
78534       {
78535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78536       };
78537     }
78538   }
78539
78540   jresult = result;
78541   return jresult;
78542 }
78543
78544
78545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78546   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78547
78548   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78549   {
78550     try {
78551       (arg1)->Enable();
78552     } catch (std::out_of_range& e) {
78553       {
78554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78555       };
78556     } catch (std::exception& e) {
78557       {
78558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78559       };
78560     } catch (Dali::DaliException e) {
78561       {
78562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78563       };
78564     } catch (...) {
78565       {
78566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78567       };
78568     }
78569   }
78570
78571 }
78572
78573
78574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78575   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78576
78577   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78578   {
78579     try {
78580       (arg1)->Disable();
78581     } catch (std::out_of_range& e) {
78582       {
78583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78584       };
78585     } catch (std::exception& e) {
78586       {
78587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78588       };
78589     } catch (Dali::DaliException e) {
78590       {
78591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78592       };
78593     } catch (...) {
78594       {
78595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78596       };
78597     }
78598   }
78599
78600 }
78601
78602
78603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78604   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78605   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78606   Dali::Toolkit::RulerDomain *argp2 ;
78607
78608   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78609   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78610   if (!argp2) {
78611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78612     return ;
78613   }
78614   arg2 = *argp2;
78615   {
78616     try {
78617       (arg1)->SetDomain(arg2);
78618     } catch (std::out_of_range& e) {
78619       {
78620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78621       };
78622     } catch (std::exception& e) {
78623       {
78624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78625       };
78626     } catch (Dali::DaliException e) {
78627       {
78628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78629       };
78630     } catch (...) {
78631       {
78632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78633       };
78634     }
78635   }
78636
78637 }
78638
78639
78640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78641   void * jresult ;
78642   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78643   Dali::Toolkit::RulerDomain *result = 0 ;
78644
78645   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78646   {
78647     try {
78648       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78649     } catch (std::out_of_range& e) {
78650       {
78651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78652       };
78653     } catch (std::exception& e) {
78654       {
78655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78656       };
78657     } catch (Dali::DaliException e) {
78658       {
78659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78660       };
78661     } catch (...) {
78662       {
78663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78664       };
78665     }
78666   }
78667
78668   jresult = (void *)result;
78669   return jresult;
78670 }
78671
78672
78673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78674   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78675
78676   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78677   {
78678     try {
78679       (arg1)->DisableDomain();
78680     } catch (std::out_of_range& e) {
78681       {
78682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78683       };
78684     } catch (std::exception& e) {
78685       {
78686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78687       };
78688     } catch (Dali::DaliException e) {
78689       {
78690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78691       };
78692     } catch (...) {
78693       {
78694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78695       };
78696     }
78697   }
78698
78699 }
78700
78701
78702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78703   float jresult ;
78704   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78705   float arg2 ;
78706   float arg3 ;
78707   float arg4 ;
78708   float result;
78709
78710   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78711   arg2 = (float)jarg2;
78712   arg3 = (float)jarg3;
78713   arg4 = (float)jarg4;
78714   {
78715     try {
78716       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78717     } catch (std::out_of_range& e) {
78718       {
78719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78720       };
78721     } catch (std::exception& e) {
78722       {
78723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (Dali::DaliException e) {
78726       {
78727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78728       };
78729     } catch (...) {
78730       {
78731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78732       };
78733     }
78734   }
78735
78736   jresult = result;
78737   return jresult;
78738 }
78739
78740
78741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78742   float jresult ;
78743   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78744   float arg2 ;
78745   float arg3 ;
78746   float result;
78747
78748   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78749   arg2 = (float)jarg2;
78750   arg3 = (float)jarg3;
78751   {
78752     try {
78753       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78754     } catch (std::out_of_range& e) {
78755       {
78756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78757       };
78758     } catch (std::exception& e) {
78759       {
78760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78761       };
78762     } catch (Dali::DaliException e) {
78763       {
78764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78765       };
78766     } catch (...) {
78767       {
78768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78769       };
78770     }
78771   }
78772
78773   jresult = result;
78774   return jresult;
78775 }
78776
78777
78778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78779   float jresult ;
78780   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78781   float arg2 ;
78782   float result;
78783
78784   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78785   arg2 = (float)jarg2;
78786   {
78787     try {
78788       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78789     } catch (std::out_of_range& e) {
78790       {
78791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78792       };
78793     } catch (std::exception& e) {
78794       {
78795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78796       };
78797     } catch (Dali::DaliException e) {
78798       {
78799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78800       };
78801     } catch (...) {
78802       {
78803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78804       };
78805     }
78806   }
78807
78808   jresult = result;
78809   return jresult;
78810 }
78811
78812
78813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78814   float jresult ;
78815   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78816   float arg2 ;
78817   float arg3 ;
78818   float arg4 ;
78819   Dali::Toolkit::ClampState *arg5 = 0 ;
78820   float result;
78821
78822   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78823   arg2 = (float)jarg2;
78824   arg3 = (float)jarg3;
78825   arg4 = (float)jarg4;
78826   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78827   if (!arg5) {
78828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78829     return 0;
78830   }
78831   {
78832     try {
78833       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78834     } catch (std::out_of_range& e) {
78835       {
78836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78837       };
78838     } catch (std::exception& e) {
78839       {
78840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78841       };
78842     } catch (Dali::DaliException e) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78845       };
78846     } catch (...) {
78847       {
78848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78849       };
78850     }
78851   }
78852
78853   jresult = result;
78854   return jresult;
78855 }
78856
78857
78858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78859   float jresult ;
78860   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78861   float arg2 ;
78862   float arg3 ;
78863   float arg4 ;
78864   float arg5 ;
78865   float result;
78866
78867   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78868   arg2 = (float)jarg2;
78869   arg3 = (float)jarg3;
78870   arg4 = (float)jarg4;
78871   arg5 = (float)jarg5;
78872   {
78873     try {
78874       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78875     } catch (std::out_of_range& e) {
78876       {
78877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78878       };
78879     } catch (std::exception& e) {
78880       {
78881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78882       };
78883     } catch (Dali::DaliException e) {
78884       {
78885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78886       };
78887     } catch (...) {
78888       {
78889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78890       };
78891     }
78892   }
78893
78894   jresult = result;
78895   return jresult;
78896 }
78897
78898
78899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78900   float jresult ;
78901   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78902   float arg2 ;
78903   float arg3 ;
78904   float arg4 ;
78905   float result;
78906
78907   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78908   arg2 = (float)jarg2;
78909   arg3 = (float)jarg3;
78910   arg4 = (float)jarg4;
78911   {
78912     try {
78913       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78914     } catch (std::out_of_range& e) {
78915       {
78916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78917       };
78918     } catch (std::exception& e) {
78919       {
78920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78921       };
78922     } catch (Dali::DaliException e) {
78923       {
78924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78925       };
78926     } catch (...) {
78927       {
78928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78929       };
78930     }
78931   }
78932
78933   jresult = result;
78934   return jresult;
78935 }
78936
78937
78938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78939   float jresult ;
78940   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78941   float arg2 ;
78942   float arg3 ;
78943   float result;
78944
78945   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78946   arg2 = (float)jarg2;
78947   arg3 = (float)jarg3;
78948   {
78949     try {
78950       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78951     } catch (std::out_of_range& e) {
78952       {
78953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78954       };
78955     } catch (std::exception& e) {
78956       {
78957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78958       };
78959     } catch (Dali::DaliException e) {
78960       {
78961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78962       };
78963     } catch (...) {
78964       {
78965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78966       };
78967     }
78968   }
78969
78970   jresult = result;
78971   return jresult;
78972 }
78973
78974
78975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78976   float jresult ;
78977   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78978   float arg2 ;
78979   float result;
78980
78981   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78982   arg2 = (float)jarg2;
78983   {
78984     try {
78985       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78986     } catch (std::out_of_range& e) {
78987       {
78988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78989       };
78990     } catch (std::exception& e) {
78991       {
78992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78993       };
78994     } catch (Dali::DaliException e) {
78995       {
78996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78997       };
78998     } catch (...) {
78999       {
79000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79001       };
79002     }
79003   }
79004
79005   jresult = result;
79006   return jresult;
79007 }
79008
79009
79010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79011   float jresult ;
79012   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79013   float arg2 ;
79014   float arg3 ;
79015   float arg4 ;
79016   float arg5 ;
79017   Dali::Toolkit::ClampState *arg6 = 0 ;
79018   float result;
79019
79020   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79021   arg2 = (float)jarg2;
79022   arg3 = (float)jarg3;
79023   arg4 = (float)jarg4;
79024   arg5 = (float)jarg5;
79025   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79026   if (!arg6) {
79027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79028     return 0;
79029   }
79030   {
79031     try {
79032       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79033     } catch (std::out_of_range& e) {
79034       {
79035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79036       };
79037     } catch (std::exception& e) {
79038       {
79039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79040       };
79041     } catch (Dali::DaliException e) {
79042       {
79043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79044       };
79045     } catch (...) {
79046       {
79047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79048       };
79049     }
79050   }
79051
79052   jresult = result;
79053   return jresult;
79054 }
79055
79056
79057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79058   void * jresult ;
79059   Dali::Toolkit::DefaultRuler *result = 0 ;
79060
79061   {
79062     try {
79063       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79064     } catch (std::out_of_range& e) {
79065       {
79066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79067       };
79068     } catch (std::exception& e) {
79069       {
79070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79071       };
79072     } catch (Dali::DaliException e) {
79073       {
79074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79075       };
79076     } catch (...) {
79077       {
79078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79079       };
79080     }
79081   }
79082
79083   jresult = (void *)result;
79084   return jresult;
79085 }
79086
79087
79088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79089   float jresult ;
79090   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79091   float arg2 ;
79092   float arg3 ;
79093   float result;
79094
79095   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79096   arg2 = (float)jarg2;
79097   arg3 = (float)jarg3;
79098   {
79099     try {
79100       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79101     } catch (std::out_of_range& e) {
79102       {
79103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79104       };
79105     } catch (std::exception& e) {
79106       {
79107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (Dali::DaliException e) {
79110       {
79111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79112       };
79113     } catch (...) {
79114       {
79115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79116       };
79117     }
79118   }
79119
79120   jresult = result;
79121   return jresult;
79122 }
79123
79124
79125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79126   float jresult ;
79127   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79128   unsigned int arg2 ;
79129   unsigned int *arg3 = 0 ;
79130   bool arg4 ;
79131   float result;
79132
79133   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79134   arg2 = (unsigned int)jarg2;
79135   arg3 = (unsigned int *)jarg3;
79136   arg4 = jarg4 ? true : false;
79137   {
79138     try {
79139       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79140     } catch (std::out_of_range& e) {
79141       {
79142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79143       };
79144     } catch (std::exception& e) {
79145       {
79146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79147       };
79148     } catch (Dali::DaliException e) {
79149       {
79150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79151       };
79152     } catch (...) {
79153       {
79154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79155       };
79156     }
79157   }
79158
79159   jresult = result;
79160   return jresult;
79161 }
79162
79163
79164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79165   unsigned int jresult ;
79166   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79167   float arg2 ;
79168   bool arg3 ;
79169   unsigned int result;
79170
79171   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79172   arg2 = (float)jarg2;
79173   arg3 = jarg3 ? true : false;
79174   {
79175     try {
79176       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79177     } catch (std::out_of_range& e) {
79178       {
79179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79180       };
79181     } catch (std::exception& e) {
79182       {
79183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79184       };
79185     } catch (Dali::DaliException e) {
79186       {
79187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79188       };
79189     } catch (...) {
79190       {
79191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79192       };
79193     }
79194   }
79195
79196   jresult = result;
79197   return jresult;
79198 }
79199
79200
79201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79202   unsigned int jresult ;
79203   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79204   unsigned int result;
79205
79206   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79207   {
79208     try {
79209       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79210     } catch (std::out_of_range& e) {
79211       {
79212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79213       };
79214     } catch (std::exception& e) {
79215       {
79216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79217       };
79218     } catch (Dali::DaliException e) {
79219       {
79220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79221       };
79222     } catch (...) {
79223       {
79224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79225       };
79226     }
79227   }
79228
79229   jresult = result;
79230   return jresult;
79231 }
79232
79233
79234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79235   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79236
79237   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79238   {
79239     try {
79240       delete arg1;
79241     } catch (std::out_of_range& e) {
79242       {
79243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79244       };
79245     } catch (std::exception& e) {
79246       {
79247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79248       };
79249     } catch (Dali::DaliException e) {
79250       {
79251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79252       };
79253     } catch (...) {
79254       {
79255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79256       };
79257     }
79258   }
79259
79260 }
79261
79262
79263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79264   void * jresult ;
79265   float arg1 ;
79266   Dali::Toolkit::FixedRuler *result = 0 ;
79267
79268   arg1 = (float)jarg1;
79269   {
79270     try {
79271       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79272     } catch (std::out_of_range& e) {
79273       {
79274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79275       };
79276     } catch (std::exception& e) {
79277       {
79278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79279       };
79280     } catch (Dali::DaliException e) {
79281       {
79282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79283       };
79284     } catch (...) {
79285       {
79286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79287       };
79288     }
79289   }
79290
79291   jresult = (void *)result;
79292   return jresult;
79293 }
79294
79295
79296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79297   void * jresult ;
79298   Dali::Toolkit::FixedRuler *result = 0 ;
79299
79300   {
79301     try {
79302       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79303     } catch (std::out_of_range& e) {
79304       {
79305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79306       };
79307     } catch (std::exception& e) {
79308       {
79309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79310       };
79311     } catch (Dali::DaliException e) {
79312       {
79313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79314       };
79315     } catch (...) {
79316       {
79317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79318       };
79319     }
79320   }
79321
79322   jresult = (void *)result;
79323   return jresult;
79324 }
79325
79326
79327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79328   float jresult ;
79329   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79330   float arg2 ;
79331   float arg3 ;
79332   float result;
79333
79334   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79335   arg2 = (float)jarg2;
79336   arg3 = (float)jarg3;
79337   {
79338     try {
79339       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79340     } catch (std::out_of_range& e) {
79341       {
79342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79343       };
79344     } catch (std::exception& e) {
79345       {
79346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79347       };
79348     } catch (Dali::DaliException e) {
79349       {
79350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79351       };
79352     } catch (...) {
79353       {
79354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79355       };
79356     }
79357   }
79358
79359   jresult = result;
79360   return jresult;
79361 }
79362
79363
79364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79365   float jresult ;
79366   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79367   unsigned int arg2 ;
79368   unsigned int *arg3 = 0 ;
79369   bool arg4 ;
79370   float result;
79371
79372   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79373   arg2 = (unsigned int)jarg2;
79374   arg3 = (unsigned int *)jarg3;
79375   arg4 = jarg4 ? true : false;
79376   {
79377     try {
79378       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79379     } catch (std::out_of_range& e) {
79380       {
79381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79382       };
79383     } catch (std::exception& e) {
79384       {
79385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79386       };
79387     } catch (Dali::DaliException e) {
79388       {
79389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79390       };
79391     } catch (...) {
79392       {
79393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79394       };
79395     }
79396   }
79397
79398   jresult = result;
79399   return jresult;
79400 }
79401
79402
79403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79404   unsigned int jresult ;
79405   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79406   float arg2 ;
79407   bool arg3 ;
79408   unsigned int result;
79409
79410   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79411   arg2 = (float)jarg2;
79412   arg3 = jarg3 ? true : false;
79413   {
79414     try {
79415       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79416     } catch (std::out_of_range& e) {
79417       {
79418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79419       };
79420     } catch (std::exception& e) {
79421       {
79422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79423       };
79424     } catch (Dali::DaliException e) {
79425       {
79426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79427       };
79428     } catch (...) {
79429       {
79430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79431       };
79432     }
79433   }
79434
79435   jresult = result;
79436   return jresult;
79437 }
79438
79439
79440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79441   unsigned int jresult ;
79442   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79443   unsigned int result;
79444
79445   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79446   {
79447     try {
79448       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79449     } catch (std::out_of_range& e) {
79450       {
79451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79452       };
79453     } catch (std::exception& e) {
79454       {
79455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79456       };
79457     } catch (Dali::DaliException e) {
79458       {
79459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79460       };
79461     } catch (...) {
79462       {
79463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79464       };
79465     }
79466   }
79467
79468   jresult = result;
79469   return jresult;
79470 }
79471
79472
79473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79474   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79475
79476   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79477   {
79478     try {
79479       delete arg1;
79480     } catch (std::out_of_range& e) {
79481       {
79482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79483       };
79484     } catch (std::exception& e) {
79485       {
79486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79487       };
79488     } catch (Dali::DaliException e) {
79489       {
79490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79491       };
79492     } catch (...) {
79493       {
79494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79495       };
79496     }
79497   }
79498
79499 }
79500
79501
79502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79503   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79504   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79505
79506   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79507   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79508   if (arg1) (arg1)->scale = *arg2;
79509 }
79510
79511
79512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79513   void * jresult ;
79514   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79515   Dali::Toolkit::ClampState2D *result = 0 ;
79516
79517   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79518   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79519   jresult = (void *)result;
79520   return jresult;
79521 }
79522
79523
79524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79525   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79526   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79527
79528   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79529   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79530   if (arg1) (arg1)->position = *arg2;
79531 }
79532
79533
79534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79535   void * jresult ;
79536   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79537   Dali::Toolkit::ClampState2D *result = 0 ;
79538
79539   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79540   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79541   jresult = (void *)result;
79542   return jresult;
79543 }
79544
79545
79546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79547   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79548   Dali::Toolkit::ClampState arg2 ;
79549
79550   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79551   arg2 = (Dali::Toolkit::ClampState)jarg2;
79552   if (arg1) (arg1)->rotation = arg2;
79553 }
79554
79555
79556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79557   int jresult ;
79558   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79559   Dali::Toolkit::ClampState result;
79560
79561   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79562   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79563   jresult = (int)result;
79564   return jresult;
79565 }
79566
79567
79568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79569   void * jresult ;
79570   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79571
79572   {
79573     try {
79574       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79575     } catch (std::out_of_range& e) {
79576       {
79577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79578       };
79579     } catch (std::exception& e) {
79580       {
79581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79582       };
79583     } catch (Dali::DaliException e) {
79584       {
79585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79586       };
79587     } catch (...) {
79588       {
79589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79590       };
79591     }
79592   }
79593
79594   jresult = (void *)result;
79595   return jresult;
79596 }
79597
79598
79599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79600   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79601
79602   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79603   {
79604     try {
79605       delete arg1;
79606     } catch (std::out_of_range& e) {
79607       {
79608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79609       };
79610     } catch (std::exception& e) {
79611       {
79612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79613       };
79614     } catch (Dali::DaliException e) {
79615       {
79616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79617       };
79618     } catch (...) {
79619       {
79620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79621       };
79622     }
79623   }
79624
79625 }
79626
79627
79628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79629   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79630   Dali::Toolkit::SnapType arg2 ;
79631
79632   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79633   arg2 = (Dali::Toolkit::SnapType)jarg2;
79634   if (arg1) (arg1)->type = arg2;
79635 }
79636
79637
79638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79639   int jresult ;
79640   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79641   Dali::Toolkit::SnapType result;
79642
79643   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79644   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79645   jresult = (int)result;
79646   return jresult;
79647 }
79648
79649
79650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79651   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79652   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79653
79654   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79655   arg2 = (Dali::Vector2 *)jarg2;
79656   if (arg1) (arg1)->position = *arg2;
79657 }
79658
79659
79660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79661   void * jresult ;
79662   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79663   Dali::Vector2 *result = 0 ;
79664
79665   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79666   result = (Dali::Vector2 *)& ((arg1)->position);
79667   jresult = (void *)result;
79668   return jresult;
79669 }
79670
79671
79672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79673   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79674   float arg2 ;
79675
79676   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79677   arg2 = (float)jarg2;
79678   if (arg1) (arg1)->duration = arg2;
79679 }
79680
79681
79682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79683   float jresult ;
79684   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79685   float result;
79686
79687   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79688   result = (float) ((arg1)->duration);
79689   jresult = result;
79690   return jresult;
79691 }
79692
79693
79694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79695   void * jresult ;
79696   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79697
79698   {
79699     try {
79700       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79701     } catch (std::out_of_range& e) {
79702       {
79703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79704       };
79705     } catch (std::exception& e) {
79706       {
79707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79708       };
79709     } catch (Dali::DaliException e) {
79710       {
79711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79712       };
79713     } catch (...) {
79714       {
79715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79716       };
79717     }
79718   }
79719
79720   jresult = (void *)result;
79721   return jresult;
79722 }
79723
79724
79725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79726   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79727
79728   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79729   {
79730     try {
79731       delete arg1;
79732     } catch (std::out_of_range& e) {
79733       {
79734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79735       };
79736     } catch (std::exception& e) {
79737       {
79738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79739       };
79740     } catch (Dali::DaliException e) {
79741       {
79742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79743       };
79744     } catch (...) {
79745       {
79746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79747       };
79748     }
79749   }
79750
79751 }
79752
79753
79754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79755   int jresult ;
79756   int result;
79757
79758   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79759   jresult = (int)result;
79760   return jresult;
79761 }
79762
79763
79764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79765   int jresult ;
79766   int result;
79767
79768   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79769   jresult = (int)result;
79770   return jresult;
79771 }
79772
79773
79774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79775   int jresult ;
79776   int result;
79777
79778   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79779   jresult = (int)result;
79780   return jresult;
79781 }
79782
79783
79784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79785   int jresult ;
79786   int result;
79787
79788   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79789   jresult = (int)result;
79790   return jresult;
79791 }
79792
79793
79794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79795   int jresult ;
79796   int result;
79797
79798   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79799   jresult = (int)result;
79800   return jresult;
79801 }
79802
79803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79804   int jresult ;
79805   int result;
79806
79807   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79808   jresult = (int)result;
79809   return jresult;
79810 }
79811
79812
79813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79814   int jresult ;
79815   int result;
79816
79817   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79818   jresult = (int)result;
79819   return jresult;
79820 }
79821
79822
79823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79824   int jresult ;
79825   int result;
79826
79827   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79828   jresult = (int)result;
79829   return jresult;
79830 }
79831
79832
79833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79834   int jresult ;
79835   int result;
79836
79837   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79838   jresult = (int)result;
79839   return jresult;
79840 }
79841
79842
79843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79844   int jresult ;
79845   int result;
79846
79847   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79848   jresult = (int)result;
79849   return jresult;
79850 }
79851
79852
79853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79854   int jresult ;
79855   int result;
79856
79857   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79858   jresult = (int)result;
79859   return jresult;
79860 }
79861
79862
79863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79864   int jresult ;
79865   int result;
79866
79867   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79868   jresult = (int)result;
79869   return jresult;
79870 }
79871
79872
79873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79874   int jresult ;
79875   int result;
79876
79877   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79878   jresult = (int)result;
79879   return jresult;
79880 }
79881
79882
79883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79884   int jresult ;
79885   int result;
79886
79887   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79888   jresult = (int)result;
79889   return jresult;
79890 }
79891
79892
79893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79894   int jresult ;
79895   int result;
79896
79897   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79898   jresult = (int)result;
79899   return jresult;
79900 }
79901
79902
79903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79904   int jresult ;
79905   int result;
79906
79907   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79908   jresult = (int)result;
79909   return jresult;
79910 }
79911
79912
79913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79914   int jresult ;
79915   int result;
79916
79917   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79918   jresult = (int)result;
79919   return jresult;
79920 }
79921
79922
79923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79924   int jresult ;
79925   int result;
79926
79927   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79928   jresult = (int)result;
79929   return jresult;
79930 }
79931
79932
79933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79934   int jresult ;
79935   int result;
79936
79937   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79938   jresult = (int)result;
79939   return jresult;
79940 }
79941
79942
79943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79944   int jresult ;
79945   int result;
79946
79947   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79948   jresult = (int)result;
79949   return jresult;
79950 }
79951
79952
79953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79954   int jresult ;
79955   int result;
79956
79957   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79958   jresult = (int)result;
79959   return jresult;
79960 }
79961
79962
79963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79964   int jresult ;
79965   int result;
79966
79967   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79968   jresult = (int)result;
79969   return jresult;
79970 }
79971
79972
79973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79974   int jresult ;
79975   int result;
79976
79977   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79978   jresult = (int)result;
79979   return jresult;
79980 }
79981
79982
79983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79984   int jresult ;
79985   int result;
79986
79987   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79988   jresult = (int)result;
79989   return jresult;
79990 }
79991
79992
79993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79994   int jresult ;
79995   int result;
79996
79997   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79998   jresult = (int)result;
79999   return jresult;
80000 }
80001
80002
80003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80004   int jresult ;
80005   int result;
80006
80007   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80008   jresult = (int)result;
80009   return jresult;
80010 }
80011
80012
80013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80014   void * jresult ;
80015   Dali::Toolkit::ScrollView::Property *result = 0 ;
80016
80017   {
80018     try {
80019       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80020     } catch (std::out_of_range& e) {
80021       {
80022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80023       };
80024     } catch (std::exception& e) {
80025       {
80026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80027       };
80028     } catch (Dali::DaliException e) {
80029       {
80030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80031       };
80032     } catch (...) {
80033       {
80034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80035       };
80036     }
80037   }
80038
80039   jresult = (void *)result;
80040   return jresult;
80041 }
80042
80043
80044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80045   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80046
80047   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80048   {
80049     try {
80050       delete arg1;
80051     } catch (std::out_of_range& e) {
80052       {
80053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80054       };
80055     } catch (std::exception& e) {
80056       {
80057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80058       };
80059     } catch (Dali::DaliException e) {
80060       {
80061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80062       };
80063     } catch (...) {
80064       {
80065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80066       };
80067     }
80068   }
80069
80070 }
80071
80072
80073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80074   void * jresult ;
80075   Dali::Toolkit::ScrollView *result = 0 ;
80076
80077   {
80078     try {
80079       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80080     } catch (std::out_of_range& e) {
80081       {
80082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80083       };
80084     } catch (std::exception& e) {
80085       {
80086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80087       };
80088     } catch (Dali::DaliException e) {
80089       {
80090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80091       };
80092     } catch (...) {
80093       {
80094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80095       };
80096     }
80097   }
80098
80099   jresult = (void *)result;
80100   return jresult;
80101 }
80102
80103
80104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80105   void * jresult ;
80106   Dali::Toolkit::ScrollView *arg1 = 0 ;
80107   Dali::Toolkit::ScrollView *result = 0 ;
80108
80109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80110   if (!arg1) {
80111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80112     return 0;
80113   }
80114   {
80115     try {
80116       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80117     } catch (std::out_of_range& e) {
80118       {
80119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80120       };
80121     } catch (std::exception& e) {
80122       {
80123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80124       };
80125     } catch (Dali::DaliException e) {
80126       {
80127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80128       };
80129     } catch (...) {
80130       {
80131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80132       };
80133     }
80134   }
80135
80136   jresult = (void *)result;
80137   return jresult;
80138 }
80139
80140
80141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80142   void * jresult ;
80143   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80144   Dali::Toolkit::ScrollView *arg2 = 0 ;
80145   Dali::Toolkit::ScrollView *result = 0 ;
80146
80147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80148   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80149   if (!arg2) {
80150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80151     return 0;
80152   }
80153   {
80154     try {
80155       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80156     } catch (std::out_of_range& e) {
80157       {
80158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80159       };
80160     } catch (std::exception& e) {
80161       {
80162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80163       };
80164     } catch (Dali::DaliException e) {
80165       {
80166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80167       };
80168     } catch (...) {
80169       {
80170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80171       };
80172     }
80173   }
80174
80175   jresult = (void *)result;
80176   return jresult;
80177 }
80178
80179
80180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80181   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80182
80183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80184   {
80185     try {
80186       delete arg1;
80187     } catch (std::out_of_range& e) {
80188       {
80189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80190       };
80191     } catch (std::exception& e) {
80192       {
80193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80194       };
80195     } catch (Dali::DaliException e) {
80196       {
80197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80198       };
80199     } catch (...) {
80200       {
80201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80202       };
80203     }
80204   }
80205
80206 }
80207
80208
80209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80210   void * jresult ;
80211   Dali::Toolkit::ScrollView result;
80212
80213   {
80214     try {
80215       result = Dali::Toolkit::ScrollView::New();
80216     } catch (std::out_of_range& e) {
80217       {
80218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80219       };
80220     } catch (std::exception& e) {
80221       {
80222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80223       };
80224     } catch (Dali::DaliException e) {
80225       {
80226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80227       };
80228     } catch (...) {
80229       {
80230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80231       };
80232     }
80233   }
80234
80235   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80236   return jresult;
80237 }
80238
80239
80240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80241   void * jresult ;
80242   Dali::BaseHandle arg1 ;
80243   Dali::BaseHandle *argp1 ;
80244   Dali::Toolkit::ScrollView result;
80245
80246   argp1 = (Dali::BaseHandle *)jarg1;
80247   if (!argp1) {
80248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80249     return 0;
80250   }
80251   arg1 = *argp1;
80252   {
80253     try {
80254       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80255     } catch (std::out_of_range& e) {
80256       {
80257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80258       };
80259     } catch (std::exception& e) {
80260       {
80261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80262       };
80263     } catch (Dali::DaliException e) {
80264       {
80265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80266       };
80267     } catch (...) {
80268       {
80269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80270       };
80271     }
80272   }
80273
80274   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80275   return jresult;
80276 }
80277
80278
80279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80280   void * jresult ;
80281   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80282   Dali::AlphaFunction result;
80283
80284   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80285   {
80286     try {
80287       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80288     } catch (std::out_of_range& e) {
80289       {
80290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80291       };
80292     } catch (std::exception& e) {
80293       {
80294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80295       };
80296     } catch (Dali::DaliException e) {
80297       {
80298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80299       };
80300     } catch (...) {
80301       {
80302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80303       };
80304     }
80305   }
80306
80307   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80308   return jresult;
80309 }
80310
80311
80312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80313   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80314   Dali::AlphaFunction arg2 ;
80315   Dali::AlphaFunction *argp2 ;
80316
80317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80318   argp2 = (Dali::AlphaFunction *)jarg2;
80319   if (!argp2) {
80320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80321     return ;
80322   }
80323   arg2 = *argp2;
80324   {
80325     try {
80326       (arg1)->SetScrollSnapAlphaFunction(arg2);
80327     } catch (std::out_of_range& e) {
80328       {
80329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80330       };
80331     } catch (std::exception& e) {
80332       {
80333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80334       };
80335     } catch (Dali::DaliException e) {
80336       {
80337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80338       };
80339     } catch (...) {
80340       {
80341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80342       };
80343     }
80344   }
80345
80346 }
80347
80348
80349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80350   void * jresult ;
80351   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80352   Dali::AlphaFunction result;
80353
80354   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80355   {
80356     try {
80357       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80358     } catch (std::out_of_range& e) {
80359       {
80360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80361       };
80362     } catch (std::exception& e) {
80363       {
80364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80365       };
80366     } catch (Dali::DaliException e) {
80367       {
80368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80369       };
80370     } catch (...) {
80371       {
80372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80373       };
80374     }
80375   }
80376
80377   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80378   return jresult;
80379 }
80380
80381
80382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80383   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80384   Dali::AlphaFunction arg2 ;
80385   Dali::AlphaFunction *argp2 ;
80386
80387   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80388   argp2 = (Dali::AlphaFunction *)jarg2;
80389   if (!argp2) {
80390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80391     return ;
80392   }
80393   arg2 = *argp2;
80394   {
80395     try {
80396       (arg1)->SetScrollFlickAlphaFunction(arg2);
80397     } catch (std::out_of_range& e) {
80398       {
80399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80400       };
80401     } catch (std::exception& e) {
80402       {
80403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80404       };
80405     } catch (Dali::DaliException e) {
80406       {
80407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80408       };
80409     } catch (...) {
80410       {
80411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80412       };
80413     }
80414   }
80415
80416 }
80417
80418
80419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80420   float jresult ;
80421   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80422   float result;
80423
80424   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80425   {
80426     try {
80427       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80428     } catch (std::out_of_range& e) {
80429       {
80430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80431       };
80432     } catch (std::exception& e) {
80433       {
80434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80435       };
80436     } catch (Dali::DaliException e) {
80437       {
80438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80439       };
80440     } catch (...) {
80441       {
80442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80443       };
80444     }
80445   }
80446
80447   jresult = result;
80448   return jresult;
80449 }
80450
80451
80452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80453   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80454   float arg2 ;
80455
80456   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80457   arg2 = (float)jarg2;
80458   {
80459     try {
80460       (arg1)->SetScrollSnapDuration(arg2);
80461     } catch (std::out_of_range& e) {
80462       {
80463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80464       };
80465     } catch (std::exception& e) {
80466       {
80467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80468       };
80469     } catch (Dali::DaliException e) {
80470       {
80471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80472       };
80473     } catch (...) {
80474       {
80475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80476       };
80477     }
80478   }
80479
80480 }
80481
80482
80483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80484   float jresult ;
80485   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80486   float result;
80487
80488   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80489   {
80490     try {
80491       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80492     } catch (std::out_of_range& e) {
80493       {
80494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80495       };
80496     } catch (std::exception& e) {
80497       {
80498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80499       };
80500     } catch (Dali::DaliException e) {
80501       {
80502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80503       };
80504     } catch (...) {
80505       {
80506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80507       };
80508     }
80509   }
80510
80511   jresult = result;
80512   return jresult;
80513 }
80514
80515
80516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80517   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80518   float arg2 ;
80519
80520   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80521   arg2 = (float)jarg2;
80522   {
80523     try {
80524       (arg1)->SetScrollFlickDuration(arg2);
80525     } catch (std::out_of_range& e) {
80526       {
80527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80528       };
80529     } catch (std::exception& e) {
80530       {
80531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80532       };
80533     } catch (Dali::DaliException e) {
80534       {
80535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80536       };
80537     } catch (...) {
80538       {
80539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80540       };
80541     }
80542   }
80543
80544 }
80545
80546
80547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80548   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80549   Dali::Toolkit::RulerPtr arg2 ;
80550   Dali::Toolkit::RulerPtr *argp2 ;
80551
80552   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80553   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80554   if (!argp2) {
80555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80556     return ;
80557   }
80558   arg2 = *argp2;
80559   {
80560     try {
80561       (arg1)->SetRulerX(arg2);
80562     } catch (std::out_of_range& e) {
80563       {
80564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80565       };
80566     } catch (std::exception& e) {
80567       {
80568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80569       };
80570     } catch (Dali::DaliException e) {
80571       {
80572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80573       };
80574     } catch (...) {
80575       {
80576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80577       };
80578     }
80579   }
80580
80581 }
80582
80583
80584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80585   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80586   Dali::Toolkit::RulerPtr arg2 ;
80587   Dali::Toolkit::RulerPtr *argp2 ;
80588
80589   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80590   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80591   if (!argp2) {
80592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80593     return ;
80594   }
80595   arg2 = *argp2;
80596   {
80597     try {
80598       (arg1)->SetRulerY(arg2);
80599     } catch (std::out_of_range& e) {
80600       {
80601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80602       };
80603     } catch (std::exception& e) {
80604       {
80605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80606       };
80607     } catch (Dali::DaliException e) {
80608       {
80609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80610       };
80611     } catch (...) {
80612       {
80613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80614       };
80615     }
80616   }
80617
80618 }
80619
80620
80621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80622   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80623   bool arg2 ;
80624
80625   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80626   arg2 = jarg2 ? true : false;
80627   {
80628     try {
80629       (arg1)->SetScrollSensitive(arg2);
80630     } catch (std::out_of_range& e) {
80631       {
80632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80633       };
80634     } catch (std::exception& e) {
80635       {
80636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80637       };
80638     } catch (Dali::DaliException e) {
80639       {
80640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80641       };
80642     } catch (...) {
80643       {
80644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80645       };
80646     }
80647   }
80648
80649 }
80650
80651
80652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80653   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80654   float arg2 ;
80655   float arg3 ;
80656
80657   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80658   arg2 = (float)jarg2;
80659   arg3 = (float)jarg3;
80660   {
80661     try {
80662       (arg1)->SetMaxOvershoot(arg2,arg3);
80663     } catch (std::out_of_range& e) {
80664       {
80665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80666       };
80667     } catch (std::exception& e) {
80668       {
80669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80670       };
80671     } catch (Dali::DaliException e) {
80672       {
80673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80674       };
80675     } catch (...) {
80676       {
80677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80678       };
80679     }
80680   }
80681
80682 }
80683
80684
80685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80686   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80687   Dali::AlphaFunction arg2 ;
80688   Dali::AlphaFunction *argp2 ;
80689
80690   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80691   argp2 = (Dali::AlphaFunction *)jarg2;
80692   if (!argp2) {
80693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80694     return ;
80695   }
80696   arg2 = *argp2;
80697   {
80698     try {
80699       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80700     } catch (std::out_of_range& e) {
80701       {
80702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80703       };
80704     } catch (std::exception& e) {
80705       {
80706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80707       };
80708     } catch (Dali::DaliException e) {
80709       {
80710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80711       };
80712     } catch (...) {
80713       {
80714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80715       };
80716     }
80717   }
80718
80719 }
80720
80721
80722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80723   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80724   float arg2 ;
80725
80726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80727   arg2 = (float)jarg2;
80728   {
80729     try {
80730       (arg1)->SetSnapOvershootDuration(arg2);
80731     } catch (std::out_of_range& e) {
80732       {
80733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80734       };
80735     } catch (std::exception& e) {
80736       {
80737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80738       };
80739     } catch (Dali::DaliException e) {
80740       {
80741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80742       };
80743     } catch (...) {
80744       {
80745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80746       };
80747     }
80748   }
80749
80750 }
80751
80752
80753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80754   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80755   bool arg2 ;
80756
80757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80758   arg2 = jarg2 ? true : false;
80759   {
80760     try {
80761       (arg1)->SetActorAutoSnap(arg2);
80762     } catch (std::out_of_range& e) {
80763       {
80764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80765       };
80766     } catch (std::exception& e) {
80767       {
80768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80769       };
80770     } catch (Dali::DaliException e) {
80771       {
80772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80773       };
80774     } catch (...) {
80775       {
80776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80777       };
80778     }
80779   }
80780
80781 }
80782
80783
80784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80785   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80786   bool arg2 ;
80787
80788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80789   arg2 = jarg2 ? true : false;
80790   {
80791     try {
80792       (arg1)->SetWrapMode(arg2);
80793     } catch (std::out_of_range& e) {
80794       {
80795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80796       };
80797     } catch (std::exception& e) {
80798       {
80799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80800       };
80801     } catch (Dali::DaliException e) {
80802       {
80803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80804       };
80805     } catch (...) {
80806       {
80807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80808       };
80809     }
80810   }
80811
80812 }
80813
80814
80815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80816   int jresult ;
80817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80818   int result;
80819
80820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80821   {
80822     try {
80823       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80824     } catch (std::out_of_range& e) {
80825       {
80826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80827       };
80828     } catch (std::exception& e) {
80829       {
80830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80831       };
80832     } catch (Dali::DaliException e) {
80833       {
80834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80835       };
80836     } catch (...) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80839       };
80840     }
80841   }
80842
80843   jresult = result;
80844   return jresult;
80845 }
80846
80847
80848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80850   int arg2 ;
80851
80852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80853   arg2 = (int)jarg2;
80854   {
80855     try {
80856       (arg1)->SetScrollUpdateDistance(arg2);
80857     } catch (std::out_of_range& e) {
80858       {
80859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80860       };
80861     } catch (std::exception& e) {
80862       {
80863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80864       };
80865     } catch (Dali::DaliException e) {
80866       {
80867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80868       };
80869     } catch (...) {
80870       {
80871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80872       };
80873     }
80874   }
80875
80876 }
80877
80878
80879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80880   unsigned int jresult ;
80881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80882   bool result;
80883
80884   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80885   {
80886     try {
80887       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80888     } catch (std::out_of_range& e) {
80889       {
80890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80891       };
80892     } catch (std::exception& e) {
80893       {
80894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80895       };
80896     } catch (Dali::DaliException e) {
80897       {
80898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80899       };
80900     } catch (...) {
80901       {
80902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80903       };
80904     }
80905   }
80906
80907   jresult = result;
80908   return jresult;
80909 }
80910
80911
80912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80913   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80914   bool arg2 ;
80915
80916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80917   arg2 = jarg2 ? true : false;
80918   {
80919     try {
80920       (arg1)->SetAxisAutoLock(arg2);
80921     } catch (std::out_of_range& e) {
80922       {
80923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80924       };
80925     } catch (std::exception& e) {
80926       {
80927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80928       };
80929     } catch (Dali::DaliException e) {
80930       {
80931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80932       };
80933     } catch (...) {
80934       {
80935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80936       };
80937     }
80938   }
80939
80940 }
80941
80942
80943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80944   float jresult ;
80945   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80946   float result;
80947
80948   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80949   {
80950     try {
80951       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80952     } catch (std::out_of_range& e) {
80953       {
80954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80955       };
80956     } catch (std::exception& e) {
80957       {
80958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80959       };
80960     } catch (Dali::DaliException e) {
80961       {
80962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80963       };
80964     } catch (...) {
80965       {
80966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80967       };
80968     }
80969   }
80970
80971   jresult = result;
80972   return jresult;
80973 }
80974
80975
80976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80977   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80978   float arg2 ;
80979
80980   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80981   arg2 = (float)jarg2;
80982   {
80983     try {
80984       (arg1)->SetAxisAutoLockGradient(arg2);
80985     } catch (std::out_of_range& e) {
80986       {
80987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80988       };
80989     } catch (std::exception& e) {
80990       {
80991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80992       };
80993     } catch (Dali::DaliException e) {
80994       {
80995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80996       };
80997     } catch (...) {
80998       {
80999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81000       };
81001     }
81002   }
81003
81004 }
81005
81006
81007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81008   float jresult ;
81009   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81010   float result;
81011
81012   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81013   {
81014     try {
81015       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81016     } catch (std::out_of_range& e) {
81017       {
81018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81019       };
81020     } catch (std::exception& e) {
81021       {
81022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81023       };
81024     } catch (Dali::DaliException e) {
81025       {
81026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81027       };
81028     } catch (...) {
81029       {
81030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81031       };
81032     }
81033   }
81034
81035   jresult = result;
81036   return jresult;
81037 }
81038
81039
81040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81041   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81042   float arg2 ;
81043
81044   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81045   arg2 = (float)jarg2;
81046   {
81047     try {
81048       (arg1)->SetFrictionCoefficient(arg2);
81049     } catch (std::out_of_range& e) {
81050       {
81051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81052       };
81053     } catch (std::exception& e) {
81054       {
81055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81056       };
81057     } catch (Dali::DaliException e) {
81058       {
81059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81060       };
81061     } catch (...) {
81062       {
81063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81064       };
81065     }
81066   }
81067
81068 }
81069
81070
81071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81072   float jresult ;
81073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81074   float result;
81075
81076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81077   {
81078     try {
81079       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81080     } catch (std::out_of_range& e) {
81081       {
81082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81083       };
81084     } catch (std::exception& e) {
81085       {
81086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81087       };
81088     } catch (Dali::DaliException e) {
81089       {
81090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81091       };
81092     } catch (...) {
81093       {
81094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81095       };
81096     }
81097   }
81098
81099   jresult = result;
81100   return jresult;
81101 }
81102
81103
81104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81106   float arg2 ;
81107
81108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81109   arg2 = (float)jarg2;
81110   {
81111     try {
81112       (arg1)->SetFlickSpeedCoefficient(arg2);
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81120       };
81121     } catch (Dali::DaliException e) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81124       };
81125     } catch (...) {
81126       {
81127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81128       };
81129     }
81130   }
81131
81132 }
81133
81134
81135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81136   void * jresult ;
81137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81138   Dali::Vector2 result;
81139
81140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81141   {
81142     try {
81143       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81144     } catch (std::out_of_range& e) {
81145       {
81146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81147       };
81148     } catch (std::exception& e) {
81149       {
81150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81151       };
81152     } catch (Dali::DaliException e) {
81153       {
81154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81155       };
81156     } catch (...) {
81157       {
81158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81159       };
81160     }
81161   }
81162
81163   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81164   return jresult;
81165 }
81166
81167
81168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81170   Dali::Vector2 *arg2 = 0 ;
81171
81172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81173   arg2 = (Dali::Vector2 *)jarg2;
81174   if (!arg2) {
81175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81176     return ;
81177   }
81178   {
81179     try {
81180       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81181     } catch (std::out_of_range& e) {
81182       {
81183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81184       };
81185     } catch (std::exception& e) {
81186       {
81187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81188       };
81189     } catch (Dali::DaliException e) {
81190       {
81191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81192       };
81193     } catch (...) {
81194       {
81195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81196       };
81197     }
81198   }
81199
81200 }
81201
81202
81203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81204   float jresult ;
81205   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81206   float result;
81207
81208   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81209   {
81210     try {
81211       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81212     } catch (std::out_of_range& e) {
81213       {
81214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81215       };
81216     } catch (std::exception& e) {
81217       {
81218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81219       };
81220     } catch (Dali::DaliException e) {
81221       {
81222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81223       };
81224     } catch (...) {
81225       {
81226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81227       };
81228     }
81229   }
81230
81231   jresult = result;
81232   return jresult;
81233 }
81234
81235
81236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81237   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81238   float arg2 ;
81239
81240   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81241   arg2 = (float)jarg2;
81242   {
81243     try {
81244       (arg1)->SetMinimumSpeedForFlick(arg2);
81245     } catch (std::out_of_range& e) {
81246       {
81247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81248       };
81249     } catch (std::exception& e) {
81250       {
81251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81252       };
81253     } catch (Dali::DaliException e) {
81254       {
81255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81256       };
81257     } catch (...) {
81258       {
81259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81260       };
81261     }
81262   }
81263
81264 }
81265
81266
81267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81268   float jresult ;
81269   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81270   float result;
81271
81272   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81273   {
81274     try {
81275       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81276     } catch (std::out_of_range& e) {
81277       {
81278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81279       };
81280     } catch (std::exception& e) {
81281       {
81282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81283       };
81284     } catch (Dali::DaliException e) {
81285       {
81286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81287       };
81288     } catch (...) {
81289       {
81290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81291       };
81292     }
81293   }
81294
81295   jresult = result;
81296   return jresult;
81297 }
81298
81299
81300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81301   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81302   float arg2 ;
81303
81304   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81305   arg2 = (float)jarg2;
81306   {
81307     try {
81308       (arg1)->SetMaxFlickSpeed(arg2);
81309     } catch (std::out_of_range& e) {
81310       {
81311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81312       };
81313     } catch (std::exception& e) {
81314       {
81315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81316       };
81317     } catch (Dali::DaliException e) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81320       };
81321     } catch (...) {
81322       {
81323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81324       };
81325     }
81326   }
81327
81328 }
81329
81330
81331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81332   void * jresult ;
81333   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81334   Dali::Vector2 result;
81335
81336   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81337   {
81338     try {
81339       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81340     } catch (std::out_of_range& e) {
81341       {
81342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81343       };
81344     } catch (std::exception& e) {
81345       {
81346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81347       };
81348     } catch (Dali::DaliException e) {
81349       {
81350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81351       };
81352     } catch (...) {
81353       {
81354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81355       };
81356     }
81357   }
81358
81359   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81360   return jresult;
81361 }
81362
81363
81364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81365   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81366   Dali::Vector2 arg2 ;
81367   Dali::Vector2 *argp2 ;
81368
81369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81370   argp2 = (Dali::Vector2 *)jarg2;
81371   if (!argp2) {
81372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81373     return ;
81374   }
81375   arg2 = *argp2;
81376   {
81377     try {
81378       (arg1)->SetWheelScrollDistanceStep(arg2);
81379     } catch (std::out_of_range& e) {
81380       {
81381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81382       };
81383     } catch (std::exception& e) {
81384       {
81385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81386       };
81387     } catch (Dali::DaliException e) {
81388       {
81389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81390       };
81391     } catch (...) {
81392       {
81393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81394       };
81395     }
81396   }
81397
81398 }
81399
81400
81401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81402   void * jresult ;
81403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81404   Dali::Vector2 result;
81405
81406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81407   {
81408     try {
81409       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81417       };
81418     } catch (Dali::DaliException e) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81421       };
81422     } catch (...) {
81423       {
81424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81425       };
81426     }
81427   }
81428
81429   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81430   return jresult;
81431 }
81432
81433
81434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81435   unsigned int jresult ;
81436   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81437   unsigned int result;
81438
81439   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81440   {
81441     try {
81442       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81443     } catch (std::out_of_range& e) {
81444       {
81445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81446       };
81447     } catch (std::exception& e) {
81448       {
81449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81450       };
81451     } catch (Dali::DaliException e) {
81452       {
81453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81454       };
81455     } catch (...) {
81456       {
81457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81458       };
81459     }
81460   }
81461
81462   jresult = result;
81463   return jresult;
81464 }
81465
81466
81467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81469   Dali::Vector2 *arg2 = 0 ;
81470
81471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81472   arg2 = (Dali::Vector2 *)jarg2;
81473   if (!arg2) {
81474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81475     return ;
81476   }
81477   {
81478     try {
81479       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81480     } catch (std::out_of_range& e) {
81481       {
81482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81483       };
81484     } catch (std::exception& e) {
81485       {
81486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81487       };
81488     } catch (Dali::DaliException e) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81491       };
81492     } catch (...) {
81493       {
81494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81495       };
81496     }
81497   }
81498
81499 }
81500
81501
81502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81504   Dali::Vector2 *arg2 = 0 ;
81505   float arg3 ;
81506
81507   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81508   arg2 = (Dali::Vector2 *)jarg2;
81509   if (!arg2) {
81510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81511     return ;
81512   }
81513   arg3 = (float)jarg3;
81514   {
81515     try {
81516       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81517     } catch (std::out_of_range& e) {
81518       {
81519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81520       };
81521     } catch (std::exception& e) {
81522       {
81523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81524       };
81525     } catch (Dali::DaliException e) {
81526       {
81527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81528       };
81529     } catch (...) {
81530       {
81531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81532       };
81533     }
81534   }
81535
81536 }
81537
81538
81539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81541   Dali::Vector2 *arg2 = 0 ;
81542   float arg3 ;
81543   Dali::AlphaFunction arg4 ;
81544   Dali::AlphaFunction *argp4 ;
81545
81546   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81547   arg2 = (Dali::Vector2 *)jarg2;
81548   if (!arg2) {
81549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81550     return ;
81551   }
81552   arg3 = (float)jarg3;
81553   argp4 = (Dali::AlphaFunction *)jarg4;
81554   if (!argp4) {
81555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81556     return ;
81557   }
81558   arg4 = *argp4;
81559   {
81560     try {
81561       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81562     } catch (std::out_of_range& e) {
81563       {
81564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81565       };
81566     } catch (std::exception& e) {
81567       {
81568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81569       };
81570     } catch (Dali::DaliException e) {
81571       {
81572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81573       };
81574     } catch (...) {
81575       {
81576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81577       };
81578     }
81579   }
81580
81581 }
81582
81583
81584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81585   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81586   Dali::Vector2 *arg2 = 0 ;
81587   float arg3 ;
81588   Dali::Toolkit::DirectionBias arg4 ;
81589   Dali::Toolkit::DirectionBias arg5 ;
81590
81591   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81592   arg2 = (Dali::Vector2 *)jarg2;
81593   if (!arg2) {
81594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81595     return ;
81596   }
81597   arg3 = (float)jarg3;
81598   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81599   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81600   {
81601     try {
81602       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81603     } catch (std::out_of_range& e) {
81604       {
81605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81606       };
81607     } catch (std::exception& e) {
81608       {
81609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81610       };
81611     } catch (Dali::DaliException e) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81614       };
81615     } catch (...) {
81616       {
81617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81618       };
81619     }
81620   }
81621
81622 }
81623
81624
81625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81627   Dali::Vector2 *arg2 = 0 ;
81628   float arg3 ;
81629   Dali::AlphaFunction arg4 ;
81630   Dali::Toolkit::DirectionBias arg5 ;
81631   Dali::Toolkit::DirectionBias arg6 ;
81632   Dali::AlphaFunction *argp4 ;
81633
81634   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81635   arg2 = (Dali::Vector2 *)jarg2;
81636   if (!arg2) {
81637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81638     return ;
81639   }
81640   arg3 = (float)jarg3;
81641   argp4 = (Dali::AlphaFunction *)jarg4;
81642   if (!argp4) {
81643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81644     return ;
81645   }
81646   arg4 = *argp4;
81647   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81648   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81649   {
81650     try {
81651       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81652     } catch (std::out_of_range& e) {
81653       {
81654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81655       };
81656     } catch (std::exception& e) {
81657       {
81658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81659       };
81660     } catch (Dali::DaliException e) {
81661       {
81662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81663       };
81664     } catch (...) {
81665       {
81666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81667       };
81668     }
81669   }
81670
81671 }
81672
81673
81674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81676   unsigned int arg2 ;
81677
81678   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81679   arg2 = (unsigned int)jarg2;
81680   {
81681     try {
81682       (arg1)->ScrollTo(arg2);
81683     } catch (std::out_of_range& e) {
81684       {
81685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81686       };
81687     } catch (std::exception& e) {
81688       {
81689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81690       };
81691     } catch (Dali::DaliException e) {
81692       {
81693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81694       };
81695     } catch (...) {
81696       {
81697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81698       };
81699     }
81700   }
81701
81702 }
81703
81704
81705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81707   unsigned int arg2 ;
81708   float arg3 ;
81709
81710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81711   arg2 = (unsigned int)jarg2;
81712   arg3 = (float)jarg3;
81713   {
81714     try {
81715       (arg1)->ScrollTo(arg2,arg3);
81716     } catch (std::out_of_range& e) {
81717       {
81718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81719       };
81720     } catch (std::exception& e) {
81721       {
81722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81723       };
81724     } catch (Dali::DaliException e) {
81725       {
81726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81727       };
81728     } catch (...) {
81729       {
81730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81731       };
81732     }
81733   }
81734
81735 }
81736
81737
81738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81740   unsigned int arg2 ;
81741   float arg3 ;
81742   Dali::Toolkit::DirectionBias arg4 ;
81743
81744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81745   arg2 = (unsigned int)jarg2;
81746   arg3 = (float)jarg3;
81747   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81748   {
81749     try {
81750       (arg1)->ScrollTo(arg2,arg3,arg4);
81751     } catch (std::out_of_range& e) {
81752       {
81753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81754       };
81755     } catch (std::exception& e) {
81756       {
81757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81758       };
81759     } catch (Dali::DaliException e) {
81760       {
81761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81762       };
81763     } catch (...) {
81764       {
81765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81766       };
81767     }
81768   }
81769
81770 }
81771
81772
81773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81775   Dali::Actor *arg2 = 0 ;
81776
81777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81778   arg2 = (Dali::Actor *)jarg2;
81779   if (!arg2) {
81780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81781     return ;
81782   }
81783   {
81784     try {
81785       (arg1)->ScrollTo(*arg2);
81786     } catch (std::out_of_range& e) {
81787       {
81788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81789       };
81790     } catch (std::exception& e) {
81791       {
81792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81793       };
81794     } catch (Dali::DaliException e) {
81795       {
81796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81797       };
81798     } catch (...) {
81799       {
81800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81801       };
81802     }
81803   }
81804
81805 }
81806
81807
81808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81809   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81810   Dali::Actor *arg2 = 0 ;
81811   float arg3 ;
81812
81813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81814   arg2 = (Dali::Actor *)jarg2;
81815   if (!arg2) {
81816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81817     return ;
81818   }
81819   arg3 = (float)jarg3;
81820   {
81821     try {
81822       (arg1)->ScrollTo(*arg2,arg3);
81823     } catch (std::out_of_range& e) {
81824       {
81825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81826       };
81827     } catch (std::exception& e) {
81828       {
81829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81830       };
81831     } catch (Dali::DaliException e) {
81832       {
81833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81834       };
81835     } catch (...) {
81836       {
81837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81838       };
81839     }
81840   }
81841
81842 }
81843
81844
81845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81846   unsigned int jresult ;
81847   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81848   bool result;
81849
81850   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81851   {
81852     try {
81853       result = (bool)(arg1)->ScrollToSnapPoint();
81854     } catch (std::out_of_range& e) {
81855       {
81856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81857       };
81858     } catch (std::exception& e) {
81859       {
81860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81861       };
81862     } catch (Dali::DaliException e) {
81863       {
81864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81865       };
81866     } catch (...) {
81867       {
81868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81869       };
81870     }
81871   }
81872
81873   jresult = result;
81874   return jresult;
81875 }
81876
81877
81878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81879   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81880   Dali::Constraint arg2 ;
81881   Dali::Constraint *argp2 ;
81882
81883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81884   argp2 = (Dali::Constraint *)jarg2;
81885   if (!argp2) {
81886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81887     return ;
81888   }
81889   arg2 = *argp2;
81890   {
81891     try {
81892       (arg1)->ApplyConstraintToChildren(arg2);
81893     } catch (std::out_of_range& e) {
81894       {
81895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81896       };
81897     } catch (std::exception& e) {
81898       {
81899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81900       };
81901     } catch (Dali::DaliException e) {
81902       {
81903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81904       };
81905     } catch (...) {
81906       {
81907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81908       };
81909     }
81910   }
81911
81912 }
81913
81914
81915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81916   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81917
81918   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81919   {
81920     try {
81921       (arg1)->RemoveConstraintsFromChildren();
81922     } catch (std::out_of_range& e) {
81923       {
81924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81925       };
81926     } catch (std::exception& e) {
81927       {
81928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81929       };
81930     } catch (Dali::DaliException e) {
81931       {
81932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81933       };
81934     } catch (...) {
81935       {
81936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81937       };
81938     }
81939   }
81940
81941 }
81942
81943
81944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81945   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81946   Dali::Toolkit::ScrollViewEffect arg2 ;
81947   Dali::Toolkit::ScrollViewEffect *argp2 ;
81948
81949   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81950   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81951   if (!argp2) {
81952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81953     return ;
81954   }
81955   arg2 = *argp2;
81956   {
81957     try {
81958       (arg1)->ApplyEffect(arg2);
81959     } catch (std::out_of_range& e) {
81960       {
81961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81962       };
81963     } catch (std::exception& e) {
81964       {
81965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81966       };
81967     } catch (Dali::DaliException e) {
81968       {
81969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81970       };
81971     } catch (...) {
81972       {
81973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81974       };
81975     }
81976   }
81977
81978 }
81979
81980
81981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81982   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81983   Dali::Toolkit::ScrollViewEffect arg2 ;
81984   Dali::Toolkit::ScrollViewEffect *argp2 ;
81985
81986   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81987   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81988   if (!argp2) {
81989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81990     return ;
81991   }
81992   arg2 = *argp2;
81993   {
81994     try {
81995       (arg1)->RemoveEffect(arg2);
81996     } catch (std::out_of_range& e) {
81997       {
81998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81999       };
82000     } catch (std::exception& e) {
82001       {
82002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82003       };
82004     } catch (Dali::DaliException e) {
82005       {
82006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82007       };
82008     } catch (...) {
82009       {
82010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82011       };
82012     }
82013   }
82014
82015 }
82016
82017
82018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82019   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82020
82021   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82022   {
82023     try {
82024       (arg1)->RemoveAllEffects();
82025     } catch (std::out_of_range& e) {
82026       {
82027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82028       };
82029     } catch (std::exception& e) {
82030       {
82031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82032       };
82033     } catch (Dali::DaliException e) {
82034       {
82035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82036       };
82037     } catch (...) {
82038       {
82039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82040       };
82041     }
82042   }
82043
82044 }
82045
82046
82047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82048   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82049   Dali::Actor arg2 ;
82050   Dali::Actor *argp2 ;
82051
82052   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82053   argp2 = (Dali::Actor *)jarg2;
82054   if (!argp2) {
82055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82056     return ;
82057   }
82058   arg2 = *argp2;
82059   {
82060     try {
82061       (arg1)->BindActor(arg2);
82062     } catch (std::out_of_range& e) {
82063       {
82064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82065       };
82066     } catch (std::exception& e) {
82067       {
82068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82069       };
82070     } catch (Dali::DaliException e) {
82071       {
82072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82073       };
82074     } catch (...) {
82075       {
82076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82077       };
82078     }
82079   }
82080
82081 }
82082
82083
82084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82085   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82086   Dali::Actor arg2 ;
82087   Dali::Actor *argp2 ;
82088
82089   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82090   argp2 = (Dali::Actor *)jarg2;
82091   if (!argp2) {
82092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82093     return ;
82094   }
82095   arg2 = *argp2;
82096   {
82097     try {
82098       (arg1)->UnbindActor(arg2);
82099     } catch (std::out_of_range& e) {
82100       {
82101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82102       };
82103     } catch (std::exception& e) {
82104       {
82105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82106       };
82107     } catch (Dali::DaliException e) {
82108       {
82109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82110       };
82111     } catch (...) {
82112       {
82113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82114       };
82115     }
82116   }
82117
82118 }
82119
82120
82121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82122   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82123   Dali::Radian arg2 ;
82124   Dali::Radian arg3 ;
82125   Dali::Radian *argp2 ;
82126   Dali::Radian *argp3 ;
82127
82128   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82129   argp2 = (Dali::Radian *)jarg2;
82130   if (!argp2) {
82131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82132     return ;
82133   }
82134   arg2 = *argp2;
82135   argp3 = (Dali::Radian *)jarg3;
82136   if (!argp3) {
82137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82138     return ;
82139   }
82140   arg3 = *argp3;
82141   {
82142     try {
82143       (arg1)->SetScrollingDirection(arg2,arg3);
82144     } catch (std::out_of_range& e) {
82145       {
82146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82147       };
82148     } catch (std::exception& e) {
82149       {
82150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82151       };
82152     } catch (Dali::DaliException e) {
82153       {
82154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82155       };
82156     } catch (...) {
82157       {
82158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82159       };
82160     }
82161   }
82162
82163 }
82164
82165
82166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82167   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82168   Dali::Radian arg2 ;
82169   Dali::Radian *argp2 ;
82170
82171   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82172   argp2 = (Dali::Radian *)jarg2;
82173   if (!argp2) {
82174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82175     return ;
82176   }
82177   arg2 = *argp2;
82178   {
82179     try {
82180       (arg1)->SetScrollingDirection(arg2);
82181     } catch (std::out_of_range& e) {
82182       {
82183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82184       };
82185     } catch (std::exception& e) {
82186       {
82187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82188       };
82189     } catch (Dali::DaliException e) {
82190       {
82191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82192       };
82193     } catch (...) {
82194       {
82195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82196       };
82197     }
82198   }
82199
82200 }
82201
82202
82203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82205   Dali::Radian arg2 ;
82206   Dali::Radian *argp2 ;
82207
82208   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82209   argp2 = (Dali::Radian *)jarg2;
82210   if (!argp2) {
82211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82212     return ;
82213   }
82214   arg2 = *argp2;
82215   {
82216     try {
82217       (arg1)->RemoveScrollingDirection(arg2);
82218     } catch (std::out_of_range& e) {
82219       {
82220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82221       };
82222     } catch (std::exception& e) {
82223       {
82224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82225       };
82226     } catch (Dali::DaliException e) {
82227       {
82228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82229       };
82230     } catch (...) {
82231       {
82232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82233       };
82234     }
82235   }
82236
82237 }
82238
82239
82240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82241   void * jresult ;
82242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82243   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82244
82245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82246   {
82247     try {
82248       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82249     } catch (std::out_of_range& e) {
82250       {
82251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82252       };
82253     } catch (std::exception& e) {
82254       {
82255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82256       };
82257     } catch (Dali::DaliException e) {
82258       {
82259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82260       };
82261     } catch (...) {
82262       {
82263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82264       };
82265     }
82266   }
82267
82268   jresult = (void *)result;
82269   return jresult;
82270 }
82271
82272
82273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82274   int jresult ;
82275   int result;
82276
82277   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82278   jresult = (int)result;
82279   return jresult;
82280 }
82281
82282
82283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82284   int jresult ;
82285   int result;
82286
82287   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82288   jresult = (int)result;
82289   return jresult;
82290 }
82291
82292
82293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82294   int jresult ;
82295   int result;
82296
82297   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82298   jresult = (int)result;
82299   return jresult;
82300 }
82301
82302
82303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82304   int jresult ;
82305   int result;
82306
82307   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82308   jresult = (int)result;
82309   return jresult;
82310 }
82311
82312
82313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82314   int jresult ;
82315   int result;
82316
82317   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82318   jresult = (int)result;
82319   return jresult;
82320 }
82321
82322
82323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82324   void * jresult ;
82325   Dali::Toolkit::TableView::Property *result = 0 ;
82326
82327   {
82328     try {
82329       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82330     } catch (std::out_of_range& e) {
82331       {
82332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82333       };
82334     } catch (std::exception& e) {
82335       {
82336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82337       };
82338     } catch (Dali::DaliException e) {
82339       {
82340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82341       };
82342     } catch (...) {
82343       {
82344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82345       };
82346     }
82347   }
82348
82349   jresult = (void *)result;
82350   return jresult;
82351 }
82352
82353
82354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82355   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82356
82357   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82358   {
82359     try {
82360       delete arg1;
82361     } catch (std::out_of_range& e) {
82362       {
82363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82364       };
82365     } catch (std::exception& e) {
82366       {
82367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82368       };
82369     } catch (Dali::DaliException e) {
82370       {
82371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82372       };
82373     } catch (...) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82376       };
82377     }
82378   }
82379
82380 }
82381
82382
82383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82384   int jresult ;
82385   int result;
82386
82387   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82388   jresult = (int)result;
82389   return jresult;
82390 }
82391
82392
82393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82394   int jresult ;
82395   int result;
82396
82397   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82398   jresult = (int)result;
82399   return jresult;
82400 }
82401
82402
82403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82404   int jresult ;
82405   int result;
82406
82407   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82408   jresult = (int)result;
82409   return jresult;
82410 }
82411
82412
82413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82414   int jresult ;
82415   int result;
82416
82417   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82418   jresult = (int)result;
82419   return jresult;
82420 }
82421
82422
82423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82424   int jresult ;
82425   int result;
82426
82427   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82428   jresult = (int)result;
82429   return jresult;
82430 }
82431
82432
82433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82434   void * jresult ;
82435   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82436
82437   {
82438     try {
82439       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82440     } catch (std::out_of_range& e) {
82441       {
82442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82443       };
82444     } catch (std::exception& e) {
82445       {
82446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82447       };
82448     } catch (Dali::DaliException e) {
82449       {
82450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82451       };
82452     } catch (...) {
82453       {
82454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82455       };
82456     }
82457   }
82458
82459   jresult = (void *)result;
82460   return jresult;
82461 }
82462
82463
82464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82465   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82466
82467   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82468   {
82469     try {
82470       delete arg1;
82471     } catch (std::out_of_range& e) {
82472       {
82473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82474       };
82475     } catch (std::exception& e) {
82476       {
82477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82478       };
82479     } catch (Dali::DaliException e) {
82480       {
82481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82482       };
82483     } catch (...) {
82484       {
82485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82486       };
82487     }
82488   }
82489
82490 }
82491
82492
82493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82494   void * jresult ;
82495   unsigned int arg1 ;
82496   unsigned int arg2 ;
82497   unsigned int arg3 ;
82498   unsigned int arg4 ;
82499   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82500
82501   arg1 = (unsigned int)jarg1;
82502   arg2 = (unsigned int)jarg2;
82503   arg3 = (unsigned int)jarg3;
82504   arg4 = (unsigned int)jarg4;
82505   {
82506     try {
82507       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82508     } catch (std::out_of_range& e) {
82509       {
82510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82511       };
82512     } catch (std::exception& e) {
82513       {
82514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82515       };
82516     } catch (Dali::DaliException e) {
82517       {
82518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82519       };
82520     } catch (...) {
82521       {
82522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82523       };
82524     }
82525   }
82526
82527   jresult = (void *)result;
82528   return jresult;
82529 }
82530
82531
82532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82533   void * jresult ;
82534   unsigned int arg1 ;
82535   unsigned int arg2 ;
82536   unsigned int arg3 ;
82537   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82538
82539   arg1 = (unsigned int)jarg1;
82540   arg2 = (unsigned int)jarg2;
82541   arg3 = (unsigned int)jarg3;
82542   {
82543     try {
82544       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82545     } catch (std::out_of_range& e) {
82546       {
82547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82548       };
82549     } catch (std::exception& e) {
82550       {
82551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82552       };
82553     } catch (Dali::DaliException e) {
82554       {
82555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82556       };
82557     } catch (...) {
82558       {
82559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82560       };
82561     }
82562   }
82563
82564   jresult = (void *)result;
82565   return jresult;
82566 }
82567
82568
82569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82570   void * jresult ;
82571   unsigned int arg1 ;
82572   unsigned int arg2 ;
82573   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82574
82575   arg1 = (unsigned int)jarg1;
82576   arg2 = (unsigned int)jarg2;
82577   {
82578     try {
82579       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82580     } catch (std::out_of_range& e) {
82581       {
82582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82583       };
82584     } catch (std::exception& e) {
82585       {
82586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82587       };
82588     } catch (Dali::DaliException e) {
82589       {
82590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82591       };
82592     } catch (...) {
82593       {
82594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82595       };
82596     }
82597   }
82598
82599   jresult = (void *)result;
82600   return jresult;
82601 }
82602
82603
82604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82605   void * jresult ;
82606   unsigned int arg1 ;
82607   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82608
82609   arg1 = (unsigned int)jarg1;
82610   {
82611     try {
82612       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82613     } catch (std::out_of_range& e) {
82614       {
82615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82616       };
82617     } catch (std::exception& e) {
82618       {
82619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82620       };
82621     } catch (Dali::DaliException e) {
82622       {
82623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82624       };
82625     } catch (...) {
82626       {
82627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82628       };
82629     }
82630   }
82631
82632   jresult = (void *)result;
82633   return jresult;
82634 }
82635
82636
82637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82638   void * jresult ;
82639   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82640
82641   {
82642     try {
82643       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82644     } catch (std::out_of_range& e) {
82645       {
82646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82647       };
82648     } catch (std::exception& e) {
82649       {
82650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82651       };
82652     } catch (Dali::DaliException e) {
82653       {
82654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82655       };
82656     } catch (...) {
82657       {
82658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82659       };
82660     }
82661   }
82662
82663   jresult = (void *)result;
82664   return jresult;
82665 }
82666
82667
82668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82669   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82670   unsigned int arg2 ;
82671
82672   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82673   arg2 = (unsigned int)jarg2;
82674   if (arg1) (arg1)->rowIndex = arg2;
82675 }
82676
82677
82678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82679   unsigned int jresult ;
82680   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82681   unsigned int result;
82682
82683   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82684   result = (unsigned int) ((arg1)->rowIndex);
82685   jresult = result;
82686   return jresult;
82687 }
82688
82689
82690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82691   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82692   unsigned int arg2 ;
82693
82694   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82695   arg2 = (unsigned int)jarg2;
82696   if (arg1) (arg1)->columnIndex = arg2;
82697 }
82698
82699
82700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82701   unsigned int jresult ;
82702   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82703   unsigned int result;
82704
82705   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82706   result = (unsigned int) ((arg1)->columnIndex);
82707   jresult = result;
82708   return jresult;
82709 }
82710
82711
82712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82713   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82714   unsigned int arg2 ;
82715
82716   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82717   arg2 = (unsigned int)jarg2;
82718   if (arg1) (arg1)->rowSpan = arg2;
82719 }
82720
82721
82722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82723   unsigned int jresult ;
82724   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82725   unsigned int result;
82726
82727   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82728   result = (unsigned int) ((arg1)->rowSpan);
82729   jresult = result;
82730   return jresult;
82731 }
82732
82733
82734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82735   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82736   unsigned int arg2 ;
82737
82738   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82739   arg2 = (unsigned int)jarg2;
82740   if (arg1) (arg1)->columnSpan = arg2;
82741 }
82742
82743
82744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82745   unsigned int jresult ;
82746   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82747   unsigned int result;
82748
82749   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82750   result = (unsigned int) ((arg1)->columnSpan);
82751   jresult = result;
82752   return jresult;
82753 }
82754
82755
82756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82757   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82758
82759   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82760   {
82761     try {
82762       delete arg1;
82763     } catch (std::out_of_range& e) {
82764       {
82765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82766       };
82767     } catch (std::exception& e) {
82768       {
82769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82770       };
82771     } catch (Dali::DaliException e) {
82772       {
82773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82774       };
82775     } catch (...) {
82776       {
82777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82778       };
82779     }
82780   }
82781
82782 }
82783
82784
82785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82786   void * jresult ;
82787   Dali::Toolkit::TableView *result = 0 ;
82788
82789   {
82790     try {
82791       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82792     } catch (std::out_of_range& e) {
82793       {
82794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82795       };
82796     } catch (std::exception& e) {
82797       {
82798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82799       };
82800     } catch (Dali::DaliException e) {
82801       {
82802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82803       };
82804     } catch (...) {
82805       {
82806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82807       };
82808     }
82809   }
82810
82811   jresult = (void *)result;
82812   return jresult;
82813 }
82814
82815
82816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82817   void * jresult ;
82818   Dali::Toolkit::TableView *arg1 = 0 ;
82819   Dali::Toolkit::TableView *result = 0 ;
82820
82821   arg1 = (Dali::Toolkit::TableView *)jarg1;
82822   if (!arg1) {
82823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82824     return 0;
82825   }
82826   {
82827     try {
82828       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82829     } catch (std::out_of_range& e) {
82830       {
82831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82832       };
82833     } catch (std::exception& e) {
82834       {
82835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82836       };
82837     } catch (Dali::DaliException e) {
82838       {
82839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82840       };
82841     } catch (...) {
82842       {
82843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82844       };
82845     }
82846   }
82847
82848   jresult = (void *)result;
82849   return jresult;
82850 }
82851
82852
82853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82854   void * jresult ;
82855   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82856   Dali::Toolkit::TableView *arg2 = 0 ;
82857   Dali::Toolkit::TableView *result = 0 ;
82858
82859   arg1 = (Dali::Toolkit::TableView *)jarg1;
82860   arg2 = (Dali::Toolkit::TableView *)jarg2;
82861   if (!arg2) {
82862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82863     return 0;
82864   }
82865   {
82866     try {
82867       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82868     } catch (std::out_of_range& e) {
82869       {
82870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82871       };
82872     } catch (std::exception& e) {
82873       {
82874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82875       };
82876     } catch (Dali::DaliException e) {
82877       {
82878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82879       };
82880     } catch (...) {
82881       {
82882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82883       };
82884     }
82885   }
82886
82887   jresult = (void *)result;
82888   return jresult;
82889 }
82890
82891
82892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82893   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82894
82895   arg1 = (Dali::Toolkit::TableView *)jarg1;
82896   {
82897     try {
82898       delete arg1;
82899     } catch (std::out_of_range& e) {
82900       {
82901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82902       };
82903     } catch (std::exception& e) {
82904       {
82905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82906       };
82907     } catch (Dali::DaliException e) {
82908       {
82909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82910       };
82911     } catch (...) {
82912       {
82913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82914       };
82915     }
82916   }
82917
82918 }
82919
82920
82921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82922   void * jresult ;
82923   unsigned int arg1 ;
82924   unsigned int arg2 ;
82925   Dali::Toolkit::TableView result;
82926
82927   arg1 = (unsigned int)jarg1;
82928   arg2 = (unsigned int)jarg2;
82929   {
82930     try {
82931       result = Dali::Toolkit::TableView::New(arg1,arg2);
82932     } catch (std::out_of_range& e) {
82933       {
82934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82935       };
82936     } catch (std::exception& e) {
82937       {
82938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82939       };
82940     } catch (Dali::DaliException e) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82943       };
82944     } catch (...) {
82945       {
82946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82947       };
82948     }
82949   }
82950
82951   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82952   return jresult;
82953 }
82954
82955
82956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82957   void * jresult ;
82958   Dali::BaseHandle arg1 ;
82959   Dali::BaseHandle *argp1 ;
82960   Dali::Toolkit::TableView result;
82961
82962   argp1 = (Dali::BaseHandle *)jarg1;
82963   if (!argp1) {
82964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82965     return 0;
82966   }
82967   arg1 = *argp1;
82968   {
82969     try {
82970       result = Dali::Toolkit::TableView::DownCast(arg1);
82971     } catch (std::out_of_range& e) {
82972       {
82973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82974       };
82975     } catch (std::exception& e) {
82976       {
82977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82978       };
82979     } catch (Dali::DaliException e) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82982       };
82983     } catch (...) {
82984       {
82985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82986       };
82987     }
82988   }
82989
82990   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82991   return jresult;
82992 }
82993
82994
82995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82996   unsigned int jresult ;
82997   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82998   Dali::Actor arg2 ;
82999   Dali::Toolkit::TableView::CellPosition arg3 ;
83000   Dali::Actor *argp2 ;
83001   Dali::Toolkit::TableView::CellPosition *argp3 ;
83002   bool result;
83003
83004   arg1 = (Dali::Toolkit::TableView *)jarg1;
83005   argp2 = (Dali::Actor *)jarg2;
83006   if (!argp2) {
83007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83008     return 0;
83009   }
83010   arg2 = *argp2;
83011   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83012   if (!argp3) {
83013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83014     return 0;
83015   }
83016   arg3 = *argp3;
83017   {
83018     try {
83019       result = (bool)(arg1)->AddChild(arg2,arg3);
83020     } catch (std::out_of_range& e) {
83021       {
83022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83023       };
83024     } catch (std::exception& e) {
83025       {
83026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83027       };
83028     } catch (Dali::DaliException e) {
83029       {
83030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83031       };
83032     } catch (...) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83035       };
83036     }
83037   }
83038
83039   jresult = result;
83040   return jresult;
83041 }
83042
83043
83044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83045   void * jresult ;
83046   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83047   Dali::Toolkit::TableView::CellPosition arg2 ;
83048   Dali::Toolkit::TableView::CellPosition *argp2 ;
83049   Dali::Actor result;
83050
83051   arg1 = (Dali::Toolkit::TableView *)jarg1;
83052   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83053   if (!argp2) {
83054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83055     return 0;
83056   }
83057   arg2 = *argp2;
83058   {
83059     try {
83060       result = (arg1)->GetChildAt(arg2);
83061     } catch (std::out_of_range& e) {
83062       {
83063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83064       };
83065     } catch (std::exception& e) {
83066       {
83067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83068       };
83069     } catch (Dali::DaliException e) {
83070       {
83071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83072       };
83073     } catch (...) {
83074       {
83075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83076       };
83077     }
83078   }
83079
83080   jresult = new Dali::Actor((const Dali::Actor &)result);
83081   return jresult;
83082 }
83083
83084
83085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83086   void * jresult ;
83087   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83088   Dali::Toolkit::TableView::CellPosition arg2 ;
83089   Dali::Toolkit::TableView::CellPosition *argp2 ;
83090   Dali::Actor result;
83091
83092   arg1 = (Dali::Toolkit::TableView *)jarg1;
83093   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83094   if (!argp2) {
83095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83096     return 0;
83097   }
83098   arg2 = *argp2;
83099   {
83100     try {
83101       result = (arg1)->RemoveChildAt(arg2);
83102     } catch (std::out_of_range& e) {
83103       {
83104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83105       };
83106     } catch (std::exception& e) {
83107       {
83108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83109       };
83110     } catch (Dali::DaliException e) {
83111       {
83112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83113       };
83114     } catch (...) {
83115       {
83116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83117       };
83118     }
83119   }
83120
83121   jresult = new Dali::Actor((const Dali::Actor &)result);
83122   return jresult;
83123 }
83124
83125
83126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83127   unsigned int jresult ;
83128   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83129   Dali::Actor arg2 ;
83130   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83131   Dali::Actor *argp2 ;
83132   bool result;
83133
83134   arg1 = (Dali::Toolkit::TableView *)jarg1;
83135   argp2 = (Dali::Actor *)jarg2;
83136   if (!argp2) {
83137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83138     return 0;
83139   }
83140   arg2 = *argp2;
83141   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83142   if (!arg3) {
83143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83144     return 0;
83145   }
83146   {
83147     try {
83148       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83149     } catch (std::out_of_range& e) {
83150       {
83151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83152       };
83153     } catch (std::exception& e) {
83154       {
83155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83156       };
83157     } catch (Dali::DaliException e) {
83158       {
83159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83160       };
83161     } catch (...) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83164       };
83165     }
83166   }
83167
83168   jresult = result;
83169   return jresult;
83170 }
83171
83172
83173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83174   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83175   unsigned int arg2 ;
83176
83177   arg1 = (Dali::Toolkit::TableView *)jarg1;
83178   arg2 = (unsigned int)jarg2;
83179   {
83180     try {
83181       (arg1)->InsertRow(arg2);
83182     } catch (std::out_of_range& e) {
83183       {
83184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83185       };
83186     } catch (std::exception& e) {
83187       {
83188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83189       };
83190     } catch (Dali::DaliException e) {
83191       {
83192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83193       };
83194     } catch (...) {
83195       {
83196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83197       };
83198     }
83199   }
83200
83201 }
83202
83203
83204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83205   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83206   unsigned int arg2 ;
83207
83208   arg1 = (Dali::Toolkit::TableView *)jarg1;
83209   arg2 = (unsigned int)jarg2;
83210   {
83211     try {
83212       (arg1)->DeleteRow(arg2);
83213     } catch (std::out_of_range& e) {
83214       {
83215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83216       };
83217     } catch (std::exception& e) {
83218       {
83219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83220       };
83221     } catch (Dali::DaliException e) {
83222       {
83223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83224       };
83225     } catch (...) {
83226       {
83227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83228       };
83229     }
83230   }
83231
83232 }
83233
83234
83235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83236   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83237   unsigned int arg2 ;
83238   std::vector< Dali::Actor > *arg3 = 0 ;
83239
83240   arg1 = (Dali::Toolkit::TableView *)jarg1;
83241   arg2 = (unsigned int)jarg2;
83242   arg3 = (std::vector< Dali::Actor > *)jarg3;
83243   if (!arg3) {
83244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83245     return ;
83246   }
83247   {
83248     try {
83249       (arg1)->DeleteRow(arg2,*arg3);
83250     } catch (std::out_of_range& e) {
83251       {
83252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83253       };
83254     } catch (std::exception& e) {
83255       {
83256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83257       };
83258     } catch (Dali::DaliException e) {
83259       {
83260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83261       };
83262     } catch (...) {
83263       {
83264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83265       };
83266     }
83267   }
83268
83269 }
83270
83271
83272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83273   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83274   unsigned int arg2 ;
83275
83276   arg1 = (Dali::Toolkit::TableView *)jarg1;
83277   arg2 = (unsigned int)jarg2;
83278   {
83279     try {
83280       (arg1)->InsertColumn(arg2);
83281     } catch (std::out_of_range& e) {
83282       {
83283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83284       };
83285     } catch (std::exception& e) {
83286       {
83287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83288       };
83289     } catch (Dali::DaliException e) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83292       };
83293     } catch (...) {
83294       {
83295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83296       };
83297     }
83298   }
83299
83300 }
83301
83302
83303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83304   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83305   unsigned int arg2 ;
83306
83307   arg1 = (Dali::Toolkit::TableView *)jarg1;
83308   arg2 = (unsigned int)jarg2;
83309   {
83310     try {
83311       (arg1)->DeleteColumn(arg2);
83312     } catch (std::out_of_range& e) {
83313       {
83314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83315       };
83316     } catch (std::exception& e) {
83317       {
83318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83319       };
83320     } catch (Dali::DaliException e) {
83321       {
83322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83323       };
83324     } catch (...) {
83325       {
83326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83327       };
83328     }
83329   }
83330
83331 }
83332
83333
83334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83335   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83336   unsigned int arg2 ;
83337   std::vector< Dali::Actor > *arg3 = 0 ;
83338
83339   arg1 = (Dali::Toolkit::TableView *)jarg1;
83340   arg2 = (unsigned int)jarg2;
83341   arg3 = (std::vector< Dali::Actor > *)jarg3;
83342   if (!arg3) {
83343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83344     return ;
83345   }
83346   {
83347     try {
83348       (arg1)->DeleteColumn(arg2,*arg3);
83349     } catch (std::out_of_range& e) {
83350       {
83351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83352       };
83353     } catch (std::exception& e) {
83354       {
83355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83356       };
83357     } catch (Dali::DaliException e) {
83358       {
83359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83360       };
83361     } catch (...) {
83362       {
83363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83364       };
83365     }
83366   }
83367
83368 }
83369
83370
83371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83372   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83373   unsigned int arg2 ;
83374   unsigned int arg3 ;
83375
83376   arg1 = (Dali::Toolkit::TableView *)jarg1;
83377   arg2 = (unsigned int)jarg2;
83378   arg3 = (unsigned int)jarg3;
83379   {
83380     try {
83381       (arg1)->Resize(arg2,arg3);
83382     } catch (std::out_of_range& e) {
83383       {
83384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83385       };
83386     } catch (std::exception& e) {
83387       {
83388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83389       };
83390     } catch (Dali::DaliException e) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83393       };
83394     } catch (...) {
83395       {
83396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83397       };
83398     }
83399   }
83400
83401 }
83402
83403
83404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83405   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83406   unsigned int arg2 ;
83407   unsigned int arg3 ;
83408   std::vector< Dali::Actor > *arg4 = 0 ;
83409
83410   arg1 = (Dali::Toolkit::TableView *)jarg1;
83411   arg2 = (unsigned int)jarg2;
83412   arg3 = (unsigned int)jarg3;
83413   arg4 = (std::vector< Dali::Actor > *)jarg4;
83414   if (!arg4) {
83415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83416     return ;
83417   }
83418   {
83419     try {
83420       (arg1)->Resize(arg2,arg3,*arg4);
83421     } catch (std::out_of_range& e) {
83422       {
83423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83424       };
83425     } catch (std::exception& e) {
83426       {
83427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83428       };
83429     } catch (Dali::DaliException e) {
83430       {
83431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83432       };
83433     } catch (...) {
83434       {
83435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83436       };
83437     }
83438   }
83439
83440 }
83441
83442
83443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83444   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83445   Dali::Size arg2 ;
83446   Dali::Size *argp2 ;
83447
83448   arg1 = (Dali::Toolkit::TableView *)jarg1;
83449   argp2 = (Dali::Size *)jarg2;
83450   if (!argp2) {
83451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83452     return ;
83453   }
83454   arg2 = *argp2;
83455   {
83456     try {
83457       (arg1)->SetCellPadding(arg2);
83458     } catch (std::out_of_range& e) {
83459       {
83460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83461       };
83462     } catch (std::exception& e) {
83463       {
83464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83465       };
83466     } catch (Dali::DaliException e) {
83467       {
83468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83469       };
83470     } catch (...) {
83471       {
83472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83473       };
83474     }
83475   }
83476
83477 }
83478
83479
83480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83481   void * jresult ;
83482   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83483   Dali::Size result;
83484
83485   arg1 = (Dali::Toolkit::TableView *)jarg1;
83486   {
83487     try {
83488       result = (arg1)->GetCellPadding();
83489     } catch (std::out_of_range& e) {
83490       {
83491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83492       };
83493     } catch (std::exception& e) {
83494       {
83495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83496       };
83497     } catch (Dali::DaliException e) {
83498       {
83499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83500       };
83501     } catch (...) {
83502       {
83503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83504       };
83505     }
83506   }
83507
83508   jresult = new Dali::Size((const Dali::Size &)result);
83509   return jresult;
83510 }
83511
83512
83513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83514   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83515   unsigned int arg2 ;
83516
83517   arg1 = (Dali::Toolkit::TableView *)jarg1;
83518   arg2 = (unsigned int)jarg2;
83519   {
83520     try {
83521       (arg1)->SetFitHeight(arg2);
83522     } catch (std::out_of_range& e) {
83523       {
83524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83525       };
83526     } catch (std::exception& e) {
83527       {
83528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83529       };
83530     } catch (Dali::DaliException e) {
83531       {
83532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83533       };
83534     } catch (...) {
83535       {
83536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83537       };
83538     }
83539   }
83540
83541 }
83542
83543
83544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83545   unsigned int jresult ;
83546   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83547   unsigned int arg2 ;
83548   bool result;
83549
83550   arg1 = (Dali::Toolkit::TableView *)jarg1;
83551   arg2 = (unsigned int)jarg2;
83552   {
83553     try {
83554       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83555     } catch (std::out_of_range& e) {
83556       {
83557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83558       };
83559     } catch (std::exception& e) {
83560       {
83561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83562       };
83563     } catch (Dali::DaliException e) {
83564       {
83565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83566       };
83567     } catch (...) {
83568       {
83569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83570       };
83571     }
83572   }
83573
83574   jresult = result;
83575   return jresult;
83576 }
83577
83578
83579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83580   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83581   unsigned int arg2 ;
83582
83583   arg1 = (Dali::Toolkit::TableView *)jarg1;
83584   arg2 = (unsigned int)jarg2;
83585   {
83586     try {
83587       (arg1)->SetFitWidth(arg2);
83588     } catch (std::out_of_range& e) {
83589       {
83590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83591       };
83592     } catch (std::exception& e) {
83593       {
83594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83595       };
83596     } catch (Dali::DaliException e) {
83597       {
83598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83599       };
83600     } catch (...) {
83601       {
83602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83603       };
83604     }
83605   }
83606
83607 }
83608
83609
83610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83611   unsigned int jresult ;
83612   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83613   unsigned int arg2 ;
83614   bool result;
83615
83616   arg1 = (Dali::Toolkit::TableView *)jarg1;
83617   arg2 = (unsigned int)jarg2;
83618   {
83619     try {
83620       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83621     } catch (std::out_of_range& e) {
83622       {
83623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83624       };
83625     } catch (std::exception& e) {
83626       {
83627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83628       };
83629     } catch (Dali::DaliException e) {
83630       {
83631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83632       };
83633     } catch (...) {
83634       {
83635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83636       };
83637     }
83638   }
83639
83640   jresult = result;
83641   return jresult;
83642 }
83643
83644
83645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83646   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83647   unsigned int arg2 ;
83648   float arg3 ;
83649
83650   arg1 = (Dali::Toolkit::TableView *)jarg1;
83651   arg2 = (unsigned int)jarg2;
83652   arg3 = (float)jarg3;
83653   {
83654     try {
83655       (arg1)->SetFixedHeight(arg2,arg3);
83656     } catch (std::out_of_range& e) {
83657       {
83658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83659       };
83660     } catch (std::exception& e) {
83661       {
83662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83663       };
83664     } catch (Dali::DaliException e) {
83665       {
83666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83667       };
83668     } catch (...) {
83669       {
83670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83671       };
83672     }
83673   }
83674
83675 }
83676
83677
83678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83679   float jresult ;
83680   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83681   unsigned int arg2 ;
83682   float result;
83683
83684   arg1 = (Dali::Toolkit::TableView *)jarg1;
83685   arg2 = (unsigned int)jarg2;
83686   {
83687     try {
83688       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83689     } catch (std::out_of_range& e) {
83690       {
83691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83692       };
83693     } catch (std::exception& e) {
83694       {
83695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83696       };
83697     } catch (Dali::DaliException e) {
83698       {
83699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83700       };
83701     } catch (...) {
83702       {
83703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83704       };
83705     }
83706   }
83707
83708   jresult = result;
83709   return jresult;
83710 }
83711
83712
83713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83714   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83715   unsigned int arg2 ;
83716   float arg3 ;
83717
83718   arg1 = (Dali::Toolkit::TableView *)jarg1;
83719   arg2 = (unsigned int)jarg2;
83720   arg3 = (float)jarg3;
83721   {
83722     try {
83723       (arg1)->SetRelativeHeight(arg2,arg3);
83724     } catch (std::out_of_range& e) {
83725       {
83726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83727       };
83728     } catch (std::exception& e) {
83729       {
83730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83731       };
83732     } catch (Dali::DaliException e) {
83733       {
83734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83735       };
83736     } catch (...) {
83737       {
83738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83739       };
83740     }
83741   }
83742
83743 }
83744
83745
83746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83747   float jresult ;
83748   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83749   unsigned int arg2 ;
83750   float result;
83751
83752   arg1 = (Dali::Toolkit::TableView *)jarg1;
83753   arg2 = (unsigned int)jarg2;
83754   {
83755     try {
83756       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83757     } catch (std::out_of_range& e) {
83758       {
83759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83760       };
83761     } catch (std::exception& e) {
83762       {
83763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83764       };
83765     } catch (Dali::DaliException e) {
83766       {
83767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83768       };
83769     } catch (...) {
83770       {
83771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83772       };
83773     }
83774   }
83775
83776   jresult = result;
83777   return jresult;
83778 }
83779
83780
83781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83782   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83783   unsigned int arg2 ;
83784   float arg3 ;
83785
83786   arg1 = (Dali::Toolkit::TableView *)jarg1;
83787   arg2 = (unsigned int)jarg2;
83788   arg3 = (float)jarg3;
83789   {
83790     try {
83791       (arg1)->SetFixedWidth(arg2,arg3);
83792     } catch (std::out_of_range& e) {
83793       {
83794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83795       };
83796     } catch (std::exception& e) {
83797       {
83798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83799       };
83800     } catch (Dali::DaliException e) {
83801       {
83802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83803       };
83804     } catch (...) {
83805       {
83806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83807       };
83808     }
83809   }
83810
83811 }
83812
83813
83814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83815   float jresult ;
83816   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83817   unsigned int arg2 ;
83818   float result;
83819
83820   arg1 = (Dali::Toolkit::TableView *)jarg1;
83821   arg2 = (unsigned int)jarg2;
83822   {
83823     try {
83824       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83825     } catch (std::out_of_range& e) {
83826       {
83827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83828       };
83829     } catch (std::exception& e) {
83830       {
83831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83832       };
83833     } catch (Dali::DaliException e) {
83834       {
83835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83836       };
83837     } catch (...) {
83838       {
83839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83840       };
83841     }
83842   }
83843
83844   jresult = result;
83845   return jresult;
83846 }
83847
83848
83849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83850   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83851   unsigned int arg2 ;
83852   float arg3 ;
83853
83854   arg1 = (Dali::Toolkit::TableView *)jarg1;
83855   arg2 = (unsigned int)jarg2;
83856   arg3 = (float)jarg3;
83857   {
83858     try {
83859       (arg1)->SetRelativeWidth(arg2,arg3);
83860     } catch (std::out_of_range& e) {
83861       {
83862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83863       };
83864     } catch (std::exception& e) {
83865       {
83866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83867       };
83868     } catch (Dali::DaliException e) {
83869       {
83870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83871       };
83872     } catch (...) {
83873       {
83874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83875       };
83876     }
83877   }
83878
83879 }
83880
83881
83882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83883   float jresult ;
83884   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83885   unsigned int arg2 ;
83886   float result;
83887
83888   arg1 = (Dali::Toolkit::TableView *)jarg1;
83889   arg2 = (unsigned int)jarg2;
83890   {
83891     try {
83892       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83893     } catch (std::out_of_range& e) {
83894       {
83895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83896       };
83897     } catch (std::exception& e) {
83898       {
83899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83900       };
83901     } catch (Dali::DaliException e) {
83902       {
83903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83904       };
83905     } catch (...) {
83906       {
83907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83908       };
83909     }
83910   }
83911
83912   jresult = result;
83913   return jresult;
83914 }
83915
83916
83917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83918   unsigned int jresult ;
83919   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83920   unsigned int result;
83921
83922   arg1 = (Dali::Toolkit::TableView *)jarg1;
83923   {
83924     try {
83925       result = (unsigned int)(arg1)->GetRows();
83926     } catch (std::out_of_range& e) {
83927       {
83928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83929       };
83930     } catch (std::exception& e) {
83931       {
83932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83933       };
83934     } catch (Dali::DaliException e) {
83935       {
83936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83937       };
83938     } catch (...) {
83939       {
83940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83941       };
83942     }
83943   }
83944
83945   jresult = result;
83946   return jresult;
83947 }
83948
83949
83950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83951   unsigned int jresult ;
83952   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83953   unsigned int result;
83954
83955   arg1 = (Dali::Toolkit::TableView *)jarg1;
83956   {
83957     try {
83958       result = (unsigned int)(arg1)->GetColumns();
83959     } catch (std::out_of_range& e) {
83960       {
83961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83962       };
83963     } catch (std::exception& e) {
83964       {
83965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83966       };
83967     } catch (Dali::DaliException e) {
83968       {
83969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83970       };
83971     } catch (...) {
83972       {
83973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83974       };
83975     }
83976   }
83977
83978   jresult = result;
83979   return jresult;
83980 }
83981
83982
83983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83984   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83985   Dali::Toolkit::TableView::CellPosition arg2 ;
83986   Dali::HorizontalAlignment::Type arg3 ;
83987   Dali::VerticalAlignment::Type arg4 ;
83988   Dali::Toolkit::TableView::CellPosition *argp2 ;
83989
83990   arg1 = (Dali::Toolkit::TableView *)jarg1;
83991   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83992   if (!argp2) {
83993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83994     return ;
83995   }
83996   arg2 = *argp2;
83997   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83998   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83999   {
84000     try {
84001       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84002     } catch (std::out_of_range& e) {
84003       {
84004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84005       };
84006     } catch (std::exception& e) {
84007       {
84008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84009       };
84010     } catch (Dali::DaliException e) {
84011       {
84012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84013       };
84014     } catch (...) {
84015       {
84016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84017       };
84018     }
84019   }
84020
84021 }
84022
84023
84024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84025   unsigned int jresult ;
84026   unsigned int result;
84027
84028   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84029   jresult = result;
84030   return jresult;
84031 }
84032
84033
84034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84035   int jresult ;
84036   int result;
84037
84038   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84039   jresult = (int)result;
84040   return jresult;
84041 }
84042
84043
84044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84045   int jresult ;
84046   int result;
84047
84048   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84049   jresult = (int)result;
84050   return jresult;
84051 }
84052
84053
84054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84055   int jresult ;
84056   int result;
84057
84058   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84059   jresult = (int)result;
84060   return jresult;
84061 }
84062
84063
84064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84065   int jresult ;
84066   int result;
84067
84068   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84069   jresult = (int)result;
84070   return jresult;
84071 }
84072
84073
84074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84075   int jresult ;
84076   int result;
84077
84078   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84079   jresult = (int)result;
84080   return jresult;
84081 }
84082
84083
84084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84085   int jresult ;
84086   int result;
84087
84088   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84089   jresult = (int)result;
84090   return jresult;
84091 }
84092
84093
84094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84095   int jresult ;
84096   int result;
84097
84098   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84099   jresult = (int)result;
84100   return jresult;
84101 }
84102
84103
84104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84105   int jresult ;
84106   int result;
84107
84108   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84109   jresult = (int)result;
84110   return jresult;
84111 }
84112
84113
84114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84115   int jresult ;
84116   int result;
84117
84118   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84119   jresult = (int)result;
84120   return jresult;
84121 }
84122
84123
84124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84125   int jresult ;
84126   int result;
84127
84128   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84129   jresult = (int)result;
84130   return jresult;
84131 }
84132
84133
84134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84135   int jresult ;
84136   int result;
84137
84138   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84139   jresult = (int)result;
84140   return jresult;
84141 }
84142
84143
84144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84145   int jresult ;
84146   int result;
84147
84148   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84149   jresult = (int)result;
84150   return jresult;
84151 }
84152
84153
84154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84155   int jresult ;
84156   int result;
84157
84158   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84159   jresult = (int)result;
84160   return jresult;
84161 }
84162
84163
84164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84165   int jresult ;
84166   int result;
84167
84168   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84169   jresult = (int)result;
84170   return jresult;
84171 }
84172
84173
84174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84175   int jresult ;
84176   int result;
84177
84178   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84179   jresult = (int)result;
84180   return jresult;
84181 }
84182
84183
84184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84185   int jresult ;
84186   int result;
84187
84188   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84189   jresult = (int)result;
84190   return jresult;
84191 }
84192
84193
84194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84195   int jresult ;
84196   int result;
84197
84198   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84199   jresult = (int)result;
84200   return jresult;
84201 }
84202
84203
84204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84205   int jresult ;
84206   int result;
84207
84208   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84209   jresult = (int)result;
84210   return jresult;
84211 }
84212
84213
84214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84215   int jresult ;
84216   int result;
84217
84218   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84219   jresult = (int)result;
84220   return jresult;
84221 }
84222
84223
84224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84225   void * jresult ;
84226   Dali::Toolkit::TextLabel::Property *result = 0 ;
84227
84228   {
84229     try {
84230       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84231     } catch (std::out_of_range& e) {
84232       {
84233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84234       };
84235     } catch (std::exception& e) {
84236       {
84237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84238       };
84239     } catch (Dali::DaliException e) {
84240       {
84241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84242       };
84243     } catch (...) {
84244       {
84245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84246       };
84247     }
84248   }
84249
84250   jresult = (void *)result;
84251   return jresult;
84252 }
84253
84254
84255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84256   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84257
84258   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84259   {
84260     try {
84261       delete arg1;
84262     } catch (std::out_of_range& e) {
84263       {
84264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84265       };
84266     } catch (std::exception& e) {
84267       {
84268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84269       };
84270     } catch (Dali::DaliException e) {
84271       {
84272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84273       };
84274     } catch (...) {
84275       {
84276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84277       };
84278     }
84279   }
84280
84281 }
84282
84283
84284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84285   void * jresult ;
84286   Dali::Toolkit::TextLabel result;
84287
84288   {
84289     try {
84290       result = Dali::Toolkit::TextLabel::New();
84291     } catch (std::out_of_range& e) {
84292       {
84293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84294       };
84295     } catch (std::exception& e) {
84296       {
84297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84298       };
84299     } catch (Dali::DaliException e) {
84300       {
84301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84302       };
84303     } catch (...) {
84304       {
84305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84306       };
84307     }
84308   }
84309
84310   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84311   return jresult;
84312 }
84313
84314
84315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84316   void * jresult ;
84317   std::string *arg1 = 0 ;
84318   Dali::Toolkit::TextLabel result;
84319
84320   if (!jarg1) {
84321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84322     return 0;
84323   }
84324   std::string arg1_str(jarg1);
84325   arg1 = &arg1_str;
84326   {
84327     try {
84328       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84329     } catch (std::out_of_range& e) {
84330       {
84331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84332       };
84333     } catch (std::exception& e) {
84334       {
84335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84336       };
84337     } catch (Dali::DaliException e) {
84338       {
84339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84340       };
84341     } catch (...) {
84342       {
84343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84344       };
84345     }
84346   }
84347
84348   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84349
84350   //argout typemap for const std::string&
84351
84352   return jresult;
84353 }
84354
84355
84356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84357   void * jresult ;
84358   Dali::Toolkit::TextLabel *result = 0 ;
84359
84360   {
84361     try {
84362       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84363     } catch (std::out_of_range& e) {
84364       {
84365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84366       };
84367     } catch (std::exception& e) {
84368       {
84369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84370       };
84371     } catch (Dali::DaliException e) {
84372       {
84373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84374       };
84375     } catch (...) {
84376       {
84377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84378       };
84379     }
84380   }
84381
84382   jresult = (void *)result;
84383   return jresult;
84384 }
84385
84386
84387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84388   void * jresult ;
84389   Dali::Toolkit::TextLabel *arg1 = 0 ;
84390   Dali::Toolkit::TextLabel *result = 0 ;
84391
84392   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84393   if (!arg1) {
84394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84395     return 0;
84396   }
84397   {
84398     try {
84399       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84400     } catch (std::out_of_range& e) {
84401       {
84402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84403       };
84404     } catch (std::exception& e) {
84405       {
84406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84407       };
84408     } catch (Dali::DaliException e) {
84409       {
84410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84411       };
84412     } catch (...) {
84413       {
84414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84415       };
84416     }
84417   }
84418
84419   jresult = (void *)result;
84420   return jresult;
84421 }
84422
84423
84424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84425   void * jresult ;
84426   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84427   Dali::Toolkit::TextLabel *arg2 = 0 ;
84428   Dali::Toolkit::TextLabel *result = 0 ;
84429
84430   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84431   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84432   if (!arg2) {
84433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84434     return 0;
84435   }
84436   {
84437     try {
84438       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84439     } catch (std::out_of_range& e) {
84440       {
84441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (std::exception& e) {
84444       {
84445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84446       };
84447     } catch (Dali::DaliException e) {
84448       {
84449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84450       };
84451     } catch (...) {
84452       {
84453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84454       };
84455     }
84456   }
84457
84458   jresult = (void *)result;
84459   return jresult;
84460 }
84461
84462
84463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84464   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84465
84466   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84467   {
84468     try {
84469       delete arg1;
84470     } catch (std::out_of_range& e) {
84471       {
84472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84473       };
84474     } catch (std::exception& e) {
84475       {
84476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84477       };
84478     } catch (Dali::DaliException e) {
84479       {
84480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84481       };
84482     } catch (...) {
84483       {
84484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84485       };
84486     }
84487   }
84488
84489 }
84490
84491
84492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84493   void * jresult ;
84494   Dali::BaseHandle arg1 ;
84495   Dali::BaseHandle *argp1 ;
84496   Dali::Toolkit::TextLabel result;
84497
84498   argp1 = (Dali::BaseHandle *)jarg1;
84499   if (!argp1) {
84500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84501     return 0;
84502   }
84503   arg1 = *argp1;
84504   {
84505     try {
84506       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84507     } catch (std::out_of_range& e) {
84508       {
84509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84510       };
84511     } catch (std::exception& e) {
84512       {
84513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84514       };
84515     } catch (Dali::DaliException e) {
84516       {
84517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84518       };
84519     } catch (...) {
84520       {
84521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84522       };
84523     }
84524   }
84525
84526   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84527   return jresult;
84528 }
84529
84530
84531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84532   void * jresult ;
84533   Dali::Toolkit::AccessibilityManager *result = 0 ;
84534
84535   {
84536     try {
84537       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84538     } catch (std::out_of_range& e) {
84539       {
84540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (std::exception& e) {
84543       {
84544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84545       };
84546     } catch (Dali::DaliException e) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84549       };
84550     } catch (...) {
84551       {
84552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84553       };
84554     }
84555   }
84556
84557   jresult = (void *)result;
84558   return jresult;
84559 }
84560
84561
84562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84563   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84564
84565   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84566   {
84567     try {
84568       delete arg1;
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84576       };
84577     } catch (Dali::DaliException e) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84580       };
84581     } catch (...) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84584       };
84585     }
84586   }
84587
84588 }
84589
84590
84591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84592   void * jresult ;
84593   Dali::Toolkit::AccessibilityManager result;
84594
84595   {
84596     try {
84597       result = Dali::Toolkit::AccessibilityManager::Get();
84598     } catch (std::out_of_range& e) {
84599       {
84600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84601       };
84602     } catch (std::exception& e) {
84603       {
84604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84605       };
84606     } catch (Dali::DaliException e) {
84607       {
84608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84609       };
84610     } catch (...) {
84611       {
84612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84613       };
84614     }
84615   }
84616
84617   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84618   return jresult;
84619 }
84620
84621
84622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84623   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84624   Dali::Actor arg2 ;
84625   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84626   std::string *arg4 = 0 ;
84627   Dali::Actor *argp2 ;
84628
84629   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84630   argp2 = (Dali::Actor *)jarg2;
84631   if (!argp2) {
84632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84633     return ;
84634   }
84635   arg2 = *argp2;
84636   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84637   if (!jarg4) {
84638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84639     return ;
84640   }
84641   std::string arg4_str(jarg4);
84642   arg4 = &arg4_str;
84643   {
84644     try {
84645       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84646     } catch (std::out_of_range& e) {
84647       {
84648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84649       };
84650     } catch (std::exception& e) {
84651       {
84652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84653       };
84654     } catch (Dali::DaliException e) {
84655       {
84656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84657       };
84658     } catch (...) {
84659       {
84660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84661       };
84662     }
84663   }
84664
84665
84666   //argout typemap for const std::string&
84667
84668 }
84669
84670
84671 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84672   char * jresult ;
84673   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84674   Dali::Actor arg2 ;
84675   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84676   Dali::Actor *argp2 ;
84677   std::string result;
84678
84679   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84680   argp2 = (Dali::Actor *)jarg2;
84681   if (!argp2) {
84682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84683     return 0;
84684   }
84685   arg2 = *argp2;
84686   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84687   {
84688     try {
84689       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84690     } catch (std::out_of_range& e) {
84691       {
84692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84693       };
84694     } catch (std::exception& e) {
84695       {
84696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84697       };
84698     } catch (Dali::DaliException e) {
84699       {
84700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84701       };
84702     } catch (...) {
84703       {
84704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84705       };
84706     }
84707   }
84708
84709   jresult = SWIG_csharp_string_callback((&result)->c_str());
84710   return jresult;
84711 }
84712
84713
84714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84715   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84716   Dali::Actor arg2 ;
84717   unsigned int arg3 ;
84718   Dali::Actor *argp2 ;
84719
84720   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84721   argp2 = (Dali::Actor *)jarg2;
84722   if (!argp2) {
84723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84724     return ;
84725   }
84726   arg2 = *argp2;
84727   arg3 = (unsigned int)jarg3;
84728   {
84729     try {
84730       (arg1)->SetFocusOrder(arg2,arg3);
84731     } catch (std::out_of_range& e) {
84732       {
84733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84734       };
84735     } catch (std::exception& e) {
84736       {
84737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84738       };
84739     } catch (Dali::DaliException e) {
84740       {
84741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84742       };
84743     } catch (...) {
84744       {
84745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84746       };
84747     }
84748   }
84749
84750 }
84751
84752
84753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84754   unsigned int jresult ;
84755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84756   Dali::Actor arg2 ;
84757   Dali::Actor *argp2 ;
84758   unsigned int result;
84759
84760   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84761   argp2 = (Dali::Actor *)jarg2;
84762   if (!argp2) {
84763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84764     return 0;
84765   }
84766   arg2 = *argp2;
84767   {
84768     try {
84769       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84770     } catch (std::out_of_range& e) {
84771       {
84772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84773       };
84774     } catch (std::exception& e) {
84775       {
84776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84777       };
84778     } catch (Dali::DaliException e) {
84779       {
84780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84781       };
84782     } catch (...) {
84783       {
84784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84785       };
84786     }
84787   }
84788
84789   jresult = result;
84790   return jresult;
84791 }
84792
84793
84794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84795   unsigned int jresult ;
84796   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84797   unsigned int result;
84798
84799   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84800   {
84801     try {
84802       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84803     } catch (std::out_of_range& e) {
84804       {
84805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84806       };
84807     } catch (std::exception& e) {
84808       {
84809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84810       };
84811     } catch (Dali::DaliException e) {
84812       {
84813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84814       };
84815     } catch (...) {
84816       {
84817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84818       };
84819     }
84820   }
84821
84822   jresult = result;
84823   return jresult;
84824 }
84825
84826
84827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84828   void * jresult ;
84829   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84830   unsigned int arg2 ;
84831   Dali::Actor result;
84832
84833   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84834   arg2 = (unsigned int)jarg2;
84835   {
84836     try {
84837       result = (arg1)->GetActorByFocusOrder(arg2);
84838     } catch (std::out_of_range& e) {
84839       {
84840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84841       };
84842     } catch (std::exception& e) {
84843       {
84844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84845       };
84846     } catch (Dali::DaliException e) {
84847       {
84848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84849       };
84850     } catch (...) {
84851       {
84852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84853       };
84854     }
84855   }
84856
84857   jresult = new Dali::Actor((const Dali::Actor &)result);
84858   return jresult;
84859 }
84860
84861
84862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84863   unsigned int jresult ;
84864   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84865   Dali::Actor arg2 ;
84866   Dali::Actor *argp2 ;
84867   bool result;
84868
84869   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84870   argp2 = (Dali::Actor *)jarg2;
84871   if (!argp2) {
84872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84873     return 0;
84874   }
84875   arg2 = *argp2;
84876   {
84877     try {
84878       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84879     } catch (std::out_of_range& e) {
84880       {
84881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84882       };
84883     } catch (std::exception& e) {
84884       {
84885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84886       };
84887     } catch (Dali::DaliException e) {
84888       {
84889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84890       };
84891     } catch (...) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84894       };
84895     }
84896   }
84897
84898   jresult = result;
84899   return jresult;
84900 }
84901
84902
84903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84904   void * jresult ;
84905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84906   Dali::Actor result;
84907
84908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84909   {
84910     try {
84911       result = (arg1)->GetCurrentFocusActor();
84912     } catch (std::out_of_range& e) {
84913       {
84914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84915       };
84916     } catch (std::exception& e) {
84917       {
84918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (Dali::DaliException e) {
84921       {
84922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84923       };
84924     } catch (...) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84927       };
84928     }
84929   }
84930
84931   jresult = new Dali::Actor((const Dali::Actor &)result);
84932   return jresult;
84933 }
84934
84935
84936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84937   void * jresult ;
84938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84939   Dali::Actor result;
84940
84941   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84942   {
84943     try {
84944       result = (arg1)->GetCurrentFocusGroup();
84945     } catch (std::out_of_range& e) {
84946       {
84947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84948       };
84949     } catch (std::exception& e) {
84950       {
84951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84952       };
84953     } catch (Dali::DaliException e) {
84954       {
84955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84956       };
84957     } catch (...) {
84958       {
84959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84960       };
84961     }
84962   }
84963
84964   jresult = new Dali::Actor((const Dali::Actor &)result);
84965   return jresult;
84966 }
84967
84968
84969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84970   unsigned int jresult ;
84971   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84972   unsigned int result;
84973
84974   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84975   {
84976     try {
84977       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84978     } catch (std::out_of_range& e) {
84979       {
84980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84981       };
84982     } catch (std::exception& e) {
84983       {
84984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84985       };
84986     } catch (Dali::DaliException e) {
84987       {
84988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84989       };
84990     } catch (...) {
84991       {
84992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84993       };
84994     }
84995   }
84996
84997   jresult = result;
84998   return jresult;
84999 }
85000
85001
85002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85003   unsigned int jresult ;
85004   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85005   bool result;
85006
85007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85008   {
85009     try {
85010       result = (bool)(arg1)->MoveFocusForward();
85011     } catch (std::out_of_range& e) {
85012       {
85013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85014       };
85015     } catch (std::exception& e) {
85016       {
85017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85018       };
85019     } catch (Dali::DaliException e) {
85020       {
85021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85022       };
85023     } catch (...) {
85024       {
85025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85026       };
85027     }
85028   }
85029
85030   jresult = result;
85031   return jresult;
85032 }
85033
85034
85035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85036   unsigned int jresult ;
85037   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85038   bool result;
85039
85040   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85041   {
85042     try {
85043       result = (bool)(arg1)->MoveFocusBackward();
85044     } catch (std::out_of_range& e) {
85045       {
85046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85047       };
85048     } catch (std::exception& e) {
85049       {
85050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (Dali::DaliException e) {
85053       {
85054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85055       };
85056     } catch (...) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85059       };
85060     }
85061   }
85062
85063   jresult = result;
85064   return jresult;
85065 }
85066
85067
85068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85069   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85070
85071   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85072   {
85073     try {
85074       (arg1)->ClearFocus();
85075     } catch (std::out_of_range& e) {
85076       {
85077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85078       };
85079     } catch (std::exception& e) {
85080       {
85081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85082       };
85083     } catch (Dali::DaliException e) {
85084       {
85085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85086       };
85087     } catch (...) {
85088       {
85089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85090       };
85091     }
85092   }
85093
85094 }
85095
85096
85097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85098   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85099
85100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85101   {
85102     try {
85103       (arg1)->Reset();
85104     } catch (std::out_of_range& e) {
85105       {
85106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85107       };
85108     } catch (std::exception& e) {
85109       {
85110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85111       };
85112     } catch (Dali::DaliException e) {
85113       {
85114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85115       };
85116     } catch (...) {
85117       {
85118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85119       };
85120     }
85121   }
85122
85123 }
85124
85125
85126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85127   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85128   Dali::Actor arg2 ;
85129   bool arg3 ;
85130   Dali::Actor *argp2 ;
85131
85132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85133   argp2 = (Dali::Actor *)jarg2;
85134   if (!argp2) {
85135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85136     return ;
85137   }
85138   arg2 = *argp2;
85139   arg3 = jarg3 ? true : false;
85140   {
85141     try {
85142       (arg1)->SetFocusGroup(arg2,arg3);
85143     } catch (std::out_of_range& e) {
85144       {
85145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85146       };
85147     } catch (std::exception& e) {
85148       {
85149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85150       };
85151     } catch (Dali::DaliException e) {
85152       {
85153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85154       };
85155     } catch (...) {
85156       {
85157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85158       };
85159     }
85160   }
85161
85162 }
85163
85164
85165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85166   unsigned int jresult ;
85167   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85168   Dali::Actor arg2 ;
85169   Dali::Actor *argp2 ;
85170   bool result;
85171
85172   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85173   argp2 = (Dali::Actor *)jarg2;
85174   if (!argp2) {
85175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85176     return 0;
85177   }
85178   arg2 = *argp2;
85179   {
85180     try {
85181       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85182     } catch (std::out_of_range& e) {
85183       {
85184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85185       };
85186     } catch (std::exception& e) {
85187       {
85188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85189       };
85190     } catch (Dali::DaliException e) {
85191       {
85192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85193       };
85194     } catch (...) {
85195       {
85196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85197       };
85198     }
85199   }
85200
85201   jresult = result;
85202   return jresult;
85203 }
85204
85205
85206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85207   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85208   bool arg2 ;
85209
85210   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85211   arg2 = jarg2 ? true : false;
85212   {
85213     try {
85214       (arg1)->SetGroupMode(arg2);
85215     } catch (std::out_of_range& e) {
85216       {
85217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85218       };
85219     } catch (std::exception& e) {
85220       {
85221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85222       };
85223     } catch (Dali::DaliException e) {
85224       {
85225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85226       };
85227     } catch (...) {
85228       {
85229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85230       };
85231     }
85232   }
85233
85234 }
85235
85236
85237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85238   unsigned int jresult ;
85239   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85240   bool result;
85241
85242   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85243   {
85244     try {
85245       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85246     } catch (std::out_of_range& e) {
85247       {
85248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (std::exception& e) {
85251       {
85252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85253       };
85254     } catch (Dali::DaliException e) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85257       };
85258     } catch (...) {
85259       {
85260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85261       };
85262     }
85263   }
85264
85265   jresult = result;
85266   return jresult;
85267 }
85268
85269
85270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85271   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85272   bool arg2 ;
85273
85274   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85275   arg2 = jarg2 ? true : false;
85276   {
85277     try {
85278       (arg1)->SetWrapMode(arg2);
85279     } catch (std::out_of_range& e) {
85280       {
85281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85282       };
85283     } catch (std::exception& e) {
85284       {
85285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85286       };
85287     } catch (Dali::DaliException e) {
85288       {
85289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85290       };
85291     } catch (...) {
85292       {
85293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85294       };
85295     }
85296   }
85297
85298 }
85299
85300
85301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85302   unsigned int jresult ;
85303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85304   bool result;
85305
85306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85307   {
85308     try {
85309       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85310     } catch (std::out_of_range& e) {
85311       {
85312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85313       };
85314     } catch (std::exception& e) {
85315       {
85316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85317       };
85318     } catch (Dali::DaliException e) {
85319       {
85320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85321       };
85322     } catch (...) {
85323       {
85324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85325       };
85326     }
85327   }
85328
85329   jresult = result;
85330   return jresult;
85331 }
85332
85333
85334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85335   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85336   Dali::Actor arg2 ;
85337   Dali::Actor *argp2 ;
85338
85339   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85340   argp2 = (Dali::Actor *)jarg2;
85341   if (!argp2) {
85342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85343     return ;
85344   }
85345   arg2 = *argp2;
85346   {
85347     try {
85348       (arg1)->SetFocusIndicatorActor(arg2);
85349     } catch (std::out_of_range& e) {
85350       {
85351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85352       };
85353     } catch (std::exception& e) {
85354       {
85355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85356       };
85357     } catch (Dali::DaliException e) {
85358       {
85359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85360       };
85361     } catch (...) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85364       };
85365     }
85366   }
85367
85368 }
85369
85370
85371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85372   void * jresult ;
85373   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85374   Dali::Actor result;
85375
85376   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85377   {
85378     try {
85379       result = (arg1)->GetFocusIndicatorActor();
85380     } catch (std::out_of_range& e) {
85381       {
85382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85383       };
85384     } catch (std::exception& e) {
85385       {
85386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85387       };
85388     } catch (Dali::DaliException e) {
85389       {
85390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85391       };
85392     } catch (...) {
85393       {
85394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85395       };
85396     }
85397   }
85398
85399   jresult = new Dali::Actor((const Dali::Actor &)result);
85400   return jresult;
85401 }
85402
85403
85404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85405   void * jresult ;
85406   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85407   Dali::Actor arg2 ;
85408   Dali::Actor *argp2 ;
85409   Dali::Actor result;
85410
85411   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85412   argp2 = (Dali::Actor *)jarg2;
85413   if (!argp2) {
85414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85415     return 0;
85416   }
85417   arg2 = *argp2;
85418   {
85419     try {
85420       result = (arg1)->GetFocusGroup(arg2);
85421     } catch (std::out_of_range& e) {
85422       {
85423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (std::exception& e) {
85426       {
85427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85428       };
85429     } catch (Dali::DaliException e) {
85430       {
85431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85432       };
85433     } catch (...) {
85434       {
85435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85436       };
85437     }
85438   }
85439
85440   jresult = new Dali::Actor((const Dali::Actor &)result);
85441   return jresult;
85442 }
85443
85444
85445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85446   void * jresult ;
85447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85448   Dali::Vector2 result;
85449
85450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85451   {
85452     try {
85453       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85454     } catch (std::out_of_range& e) {
85455       {
85456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85457       };
85458     } catch (std::exception& e) {
85459       {
85460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85461       };
85462     } catch (Dali::DaliException e) {
85463       {
85464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85465       };
85466     } catch (...) {
85467       {
85468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85469       };
85470     }
85471   }
85472
85473   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85474   return jresult;
85475 }
85476
85477
85478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85479   void * jresult ;
85480   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85481   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85482
85483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85484   {
85485     try {
85486       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85487     } catch (std::out_of_range& e) {
85488       {
85489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85490       };
85491     } catch (std::exception& e) {
85492       {
85493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85494       };
85495     } catch (Dali::DaliException e) {
85496       {
85497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85498       };
85499     } catch (...) {
85500       {
85501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85502       };
85503     }
85504   }
85505
85506   jresult = (void *)result;
85507   return jresult;
85508 }
85509
85510
85511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85512   void * jresult ;
85513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85514   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85515
85516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85517   {
85518     try {
85519       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85520     } catch (std::out_of_range& e) {
85521       {
85522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85523       };
85524     } catch (std::exception& e) {
85525       {
85526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85527       };
85528     } catch (Dali::DaliException e) {
85529       {
85530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85531       };
85532     } catch (...) {
85533       {
85534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85535       };
85536     }
85537   }
85538
85539   jresult = (void *)result;
85540   return jresult;
85541 }
85542
85543
85544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85545   void * jresult ;
85546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85547   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85548
85549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85550   {
85551     try {
85552       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85553     } catch (std::out_of_range& e) {
85554       {
85555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85556       };
85557     } catch (std::exception& e) {
85558       {
85559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85560       };
85561     } catch (Dali::DaliException e) {
85562       {
85563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85564       };
85565     } catch (...) {
85566       {
85567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85568       };
85569     }
85570   }
85571
85572   jresult = (void *)result;
85573   return jresult;
85574 }
85575
85576
85577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85578   void * jresult ;
85579   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85580   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85581
85582   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85583   {
85584     try {
85585       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85586     } catch (std::out_of_range& e) {
85587       {
85588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85589       };
85590     } catch (std::exception& e) {
85591       {
85592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85593       };
85594     } catch (Dali::DaliException e) {
85595       {
85596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85597       };
85598     } catch (...) {
85599       {
85600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85601       };
85602     }
85603   }
85604
85605   jresult = (void *)result;
85606   return jresult;
85607 }
85608
85609
85610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85611   void * jresult ;
85612   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85613   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85614
85615   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85616   {
85617     try {
85618       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85619     } catch (std::out_of_range& e) {
85620       {
85621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85622       };
85623     } catch (std::exception& e) {
85624       {
85625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85626       };
85627     } catch (Dali::DaliException e) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85630       };
85631     } catch (...) {
85632       {
85633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85634       };
85635     }
85636   }
85637
85638   jresult = (void *)result;
85639   return jresult;
85640 }
85641
85642
85643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85644   void * jresult ;
85645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85646   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85647
85648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85649   {
85650     try {
85651       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85652     } catch (std::out_of_range& e) {
85653       {
85654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85655       };
85656     } catch (std::exception& e) {
85657       {
85658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85659       };
85660     } catch (Dali::DaliException e) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85663       };
85664     } catch (...) {
85665       {
85666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85667       };
85668     }
85669   }
85670
85671   jresult = (void *)result;
85672   return jresult;
85673 }
85674
85675
85676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85677   void * jresult ;
85678   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85679   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85680
85681   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85682   {
85683     try {
85684       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85685     } catch (std::out_of_range& e) {
85686       {
85687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85688       };
85689     } catch (std::exception& e) {
85690       {
85691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85692       };
85693     } catch (Dali::DaliException e) {
85694       {
85695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85696       };
85697     } catch (...) {
85698       {
85699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85700       };
85701     }
85702   }
85703
85704   jresult = (void *)result;
85705   return jresult;
85706 }
85707
85708
85709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85710   void * jresult ;
85711   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85712   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85713
85714   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85715   {
85716     try {
85717       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85718     } catch (std::out_of_range& e) {
85719       {
85720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85721       };
85722     } catch (std::exception& e) {
85723       {
85724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85725       };
85726     } catch (Dali::DaliException e) {
85727       {
85728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85729       };
85730     } catch (...) {
85731       {
85732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85733       };
85734     }
85735   }
85736
85737   jresult = (void *)result;
85738   return jresult;
85739 }
85740
85741
85742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85743   void * jresult ;
85744   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85745   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85746
85747   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85748   {
85749     try {
85750       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85751     } catch (std::out_of_range& e) {
85752       {
85753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85754       };
85755     } catch (std::exception& e) {
85756       {
85757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85758       };
85759     } catch (Dali::DaliException e) {
85760       {
85761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85762       };
85763     } catch (...) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85766       };
85767     }
85768   }
85769
85770   jresult = (void *)result;
85771   return jresult;
85772 }
85773
85774
85775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85776   void * jresult ;
85777   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85778   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85779
85780   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85781   {
85782     try {
85783       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85784     } catch (std::out_of_range& e) {
85785       {
85786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85787       };
85788     } catch (std::exception& e) {
85789       {
85790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85791       };
85792     } catch (Dali::DaliException e) {
85793       {
85794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85795       };
85796     } catch (...) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85799       };
85800     }
85801   }
85802
85803   jresult = (void *)result;
85804   return jresult;
85805 }
85806
85807
85808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85809   void * jresult ;
85810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85811   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85812
85813   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85814   {
85815     try {
85816       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85817     } catch (std::out_of_range& e) {
85818       {
85819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85820       };
85821     } catch (std::exception& e) {
85822       {
85823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85824       };
85825     } catch (Dali::DaliException e) {
85826       {
85827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85828       };
85829     } catch (...) {
85830       {
85831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85832       };
85833     }
85834   }
85835
85836   jresult = (void *)result;
85837   return jresult;
85838 }
85839
85840
85841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85842   void * jresult ;
85843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85844   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85845
85846   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85847   {
85848     try {
85849       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (Dali::DaliException e) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85861       };
85862     } catch (...) {
85863       {
85864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85865       };
85866     }
85867   }
85868
85869   jresult = (void *)result;
85870   return jresult;
85871 }
85872
85873
85874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85875   void * jresult ;
85876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85877   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85878
85879   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85880   {
85881     try {
85882       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85883     } catch (std::out_of_range& e) {
85884       {
85885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (std::exception& e) {
85888       {
85889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (Dali::DaliException e) {
85892       {
85893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85894       };
85895     } catch (...) {
85896       {
85897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85898       };
85899     }
85900   }
85901
85902   jresult = (void *)result;
85903   return jresult;
85904 }
85905
85906
85907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85908   void * jresult ;
85909   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85910   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85911
85912   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85913   {
85914     try {
85915       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85916     } catch (std::out_of_range& e) {
85917       {
85918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85919       };
85920     } catch (std::exception& e) {
85921       {
85922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85923       };
85924     } catch (Dali::DaliException e) {
85925       {
85926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85927       };
85928     } catch (...) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85931       };
85932     }
85933   }
85934
85935   jresult = (void *)result;
85936   return jresult;
85937 }
85938
85939
85940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85941   void * jresult ;
85942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85943   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85944
85945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85946   {
85947     try {
85948       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85949     } catch (std::out_of_range& e) {
85950       {
85951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85952       };
85953     } catch (std::exception& e) {
85954       {
85955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85956       };
85957     } catch (Dali::DaliException e) {
85958       {
85959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85960       };
85961     } catch (...) {
85962       {
85963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85964       };
85965     }
85966   }
85967
85968   jresult = (void *)result;
85969   return jresult;
85970 }
85971
85972
85973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85974   void * jresult ;
85975   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85976   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85977
85978   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85979   {
85980     try {
85981       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85982     } catch (std::out_of_range& e) {
85983       {
85984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85985       };
85986     } catch (std::exception& e) {
85987       {
85988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85989       };
85990     } catch (Dali::DaliException e) {
85991       {
85992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85993       };
85994     } catch (...) {
85995       {
85996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85997       };
85998     }
85999   }
86000
86001   jresult = (void *)result;
86002   return jresult;
86003 }
86004
86005
86006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86007   void * jresult ;
86008   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86009   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86010
86011   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86012   {
86013     try {
86014       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86015     } catch (std::out_of_range& e) {
86016       {
86017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86018       };
86019     } catch (std::exception& e) {
86020       {
86021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86022       };
86023     } catch (Dali::DaliException e) {
86024       {
86025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86026       };
86027     } catch (...) {
86028       {
86029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86030       };
86031     }
86032   }
86033
86034   jresult = (void *)result;
86035   return jresult;
86036 }
86037
86038
86039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86040   void * jresult ;
86041   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86042   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86043
86044   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86045   {
86046     try {
86047       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86048     } catch (std::out_of_range& e) {
86049       {
86050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86051       };
86052     } catch (std::exception& e) {
86053       {
86054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86055       };
86056     } catch (Dali::DaliException e) {
86057       {
86058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86059       };
86060     } catch (...) {
86061       {
86062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86063       };
86064     }
86065   }
86066
86067   jresult = (void *)result;
86068   return jresult;
86069 }
86070
86071
86072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86073   void * jresult ;
86074   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86075   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86076
86077   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86078   {
86079     try {
86080       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86081     } catch (std::out_of_range& e) {
86082       {
86083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86084       };
86085     } catch (std::exception& e) {
86086       {
86087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86088       };
86089     } catch (Dali::DaliException e) {
86090       {
86091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86092       };
86093     } catch (...) {
86094       {
86095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86096       };
86097     }
86098   }
86099
86100   jresult = (void *)result;
86101   return jresult;
86102 }
86103
86104
86105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86106   void * jresult ;
86107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86108   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86109
86110   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86111   {
86112     try {
86113       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86114     } catch (std::out_of_range& e) {
86115       {
86116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86117       };
86118     } catch (std::exception& e) {
86119       {
86120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86121       };
86122     } catch (Dali::DaliException e) {
86123       {
86124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86125       };
86126     } catch (...) {
86127       {
86128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86129       };
86130     }
86131   }
86132
86133   jresult = (void *)result;
86134   return jresult;
86135 }
86136
86137
86138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86139   void * jresult ;
86140   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86141   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86142
86143   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86144   {
86145     try {
86146       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86147     } catch (std::out_of_range& e) {
86148       {
86149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86150       };
86151     } catch (std::exception& e) {
86152       {
86153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86154       };
86155     } catch (Dali::DaliException e) {
86156       {
86157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86158       };
86159     } catch (...) {
86160       {
86161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86162       };
86163     }
86164   }
86165
86166   jresult = (void *)result;
86167   return jresult;
86168 }
86169
86170
86171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86172   void * jresult ;
86173   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86174   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86175
86176   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86177   {
86178     try {
86179       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86180     } catch (std::out_of_range& e) {
86181       {
86182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86183       };
86184     } catch (std::exception& e) {
86185       {
86186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86187       };
86188     } catch (Dali::DaliException e) {
86189       {
86190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86191       };
86192     } catch (...) {
86193       {
86194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86195       };
86196     }
86197   }
86198
86199   jresult = (void *)result;
86200   return jresult;
86201 }
86202
86203
86204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86205   void * jresult ;
86206   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86207   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86208
86209   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86210   {
86211     try {
86212       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86213     } catch (std::out_of_range& e) {
86214       {
86215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86216       };
86217     } catch (std::exception& e) {
86218       {
86219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86220       };
86221     } catch (Dali::DaliException e) {
86222       {
86223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86224       };
86225     } catch (...) {
86226       {
86227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86228       };
86229     }
86230   }
86231
86232   jresult = (void *)result;
86233   return jresult;
86234 }
86235
86236
86237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86238   void * jresult ;
86239   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86240   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86241
86242   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86243   {
86244     try {
86245       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86246     } catch (std::out_of_range& e) {
86247       {
86248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86249       };
86250     } catch (std::exception& e) {
86251       {
86252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86253       };
86254     } catch (Dali::DaliException e) {
86255       {
86256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86257       };
86258     } catch (...) {
86259       {
86260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86261       };
86262     }
86263   }
86264
86265   jresult = (void *)result;
86266   return jresult;
86267 }
86268
86269
86270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86271   void * jresult ;
86272   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86273   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86274
86275   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86276   {
86277     try {
86278       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86279     } catch (std::out_of_range& e) {
86280       {
86281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86282       };
86283     } catch (std::exception& e) {
86284       {
86285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86286       };
86287     } catch (Dali::DaliException e) {
86288       {
86289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86290       };
86291     } catch (...) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86294       };
86295     }
86296   }
86297
86298   jresult = (void *)result;
86299   return jresult;
86300 }
86301
86302
86303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86304   void * jresult ;
86305   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86306   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86307
86308   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86309   {
86310     try {
86311       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86312     } catch (std::out_of_range& e) {
86313       {
86314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86315       };
86316     } catch (std::exception& e) {
86317       {
86318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86319       };
86320     } catch (Dali::DaliException e) {
86321       {
86322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86323       };
86324     } catch (...) {
86325       {
86326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86327       };
86328     }
86329   }
86330
86331   jresult = (void *)result;
86332   return jresult;
86333 }
86334
86335
86336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86337   void * jresult ;
86338   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86339   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86340
86341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86342   {
86343     try {
86344       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86345     } catch (std::out_of_range& e) {
86346       {
86347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86348       };
86349     } catch (std::exception& e) {
86350       {
86351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86352       };
86353     } catch (Dali::DaliException e) {
86354       {
86355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86356       };
86357     } catch (...) {
86358       {
86359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86360       };
86361     }
86362   }
86363
86364   jresult = (void *)result;
86365   return jresult;
86366 }
86367
86368
86369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86370   void * jresult ;
86371   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86372   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86373
86374   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86375   {
86376     try {
86377       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86378     } catch (std::out_of_range& e) {
86379       {
86380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86381       };
86382     } catch (std::exception& e) {
86383       {
86384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86385       };
86386     } catch (Dali::DaliException e) {
86387       {
86388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86389       };
86390     } catch (...) {
86391       {
86392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86393       };
86394     }
86395   }
86396
86397   jresult = (void *)result;
86398   return jresult;
86399 }
86400
86401
86402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86403   void * jresult ;
86404   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86405   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86406
86407   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86408   {
86409     try {
86410       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86411     } catch (std::out_of_range& e) {
86412       {
86413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86414       };
86415     } catch (std::exception& e) {
86416       {
86417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86418       };
86419     } catch (Dali::DaliException e) {
86420       {
86421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86422       };
86423     } catch (...) {
86424       {
86425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86426       };
86427     }
86428   }
86429
86430   jresult = (void *)result;
86431   return jresult;
86432 }
86433
86434
86435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86436   void * jresult ;
86437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86438   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86439
86440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86441   {
86442     try {
86443       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86444     } catch (std::out_of_range& e) {
86445       {
86446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86447       };
86448     } catch (std::exception& e) {
86449       {
86450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86451       };
86452     } catch (Dali::DaliException e) {
86453       {
86454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86455       };
86456     } catch (...) {
86457       {
86458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86459       };
86460     }
86461   }
86462
86463   jresult = (void *)result;
86464   return jresult;
86465 }
86466
86467
86468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86469   void * jresult ;
86470   Dali::Toolkit::StyleManager *result = 0 ;
86471
86472   {
86473     try {
86474       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86475     } catch (std::out_of_range& e) {
86476       {
86477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86478       };
86479     } catch (std::exception& e) {
86480       {
86481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86482       };
86483     } catch (Dali::DaliException e) {
86484       {
86485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86486       };
86487     } catch (...) {
86488       {
86489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86490       };
86491     }
86492   }
86493
86494   jresult = (void *)result;
86495   return jresult;
86496 }
86497
86498
86499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86500   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86501
86502   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86503   {
86504     try {
86505       delete arg1;
86506     } catch (std::out_of_range& e) {
86507       {
86508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86509       };
86510     } catch (std::exception& e) {
86511       {
86512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86513       };
86514     } catch (Dali::DaliException e) {
86515       {
86516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86517       };
86518     } catch (...) {
86519       {
86520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86521       };
86522     }
86523   }
86524
86525 }
86526
86527
86528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86529   void * jresult ;
86530   Dali::Toolkit::StyleManager result;
86531
86532   {
86533     try {
86534       result = Dali::Toolkit::StyleManager::Get();
86535     } catch (std::out_of_range& e) {
86536       {
86537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86538       };
86539     } catch (std::exception& e) {
86540       {
86541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86542       };
86543     } catch (Dali::DaliException e) {
86544       {
86545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86546       };
86547     } catch (...) {
86548       {
86549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86550       };
86551     }
86552   }
86553
86554   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86555   return jresult;
86556 }
86557
86558
86559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86560   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86561   std::string *arg2 = 0 ;
86562
86563   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86564   if (!jarg2) {
86565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86566     return ;
86567   }
86568   std::string arg2_str(jarg2);
86569   arg2 = &arg2_str;
86570   {
86571     try {
86572       (arg1)->ApplyTheme((std::string const &)*arg2);
86573     } catch (std::out_of_range& e) {
86574       {
86575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86576       };
86577     } catch (std::exception& e) {
86578       {
86579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86580       };
86581     } catch (Dali::DaliException e) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86584       };
86585     } catch (...) {
86586       {
86587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86588       };
86589     }
86590   }
86591
86592
86593   //argout typemap for const std::string&
86594
86595 }
86596
86597
86598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86599   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86600
86601   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86602   {
86603     try {
86604       (arg1)->ApplyDefaultTheme();
86605     } catch (std::out_of_range& e) {
86606       {
86607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86608       };
86609     } catch (std::exception& e) {
86610       {
86611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86612       };
86613     } catch (Dali::DaliException e) {
86614       {
86615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86616       };
86617     } catch (...) {
86618       {
86619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86620       };
86621     }
86622   }
86623
86624 }
86625
86626
86627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86628   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86629   std::string *arg2 = 0 ;
86630   Dali::Property::Value *arg3 = 0 ;
86631
86632   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86633   if (!jarg2) {
86634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86635     return ;
86636   }
86637   std::string arg2_str(jarg2);
86638   arg2 = &arg2_str;
86639   arg3 = (Dali::Property::Value *)jarg3;
86640   if (!arg3) {
86641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86642     return ;
86643   }
86644   {
86645     try {
86646       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86647     } catch (std::out_of_range& e) {
86648       {
86649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86650       };
86651     } catch (std::exception& e) {
86652       {
86653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86654       };
86655     } catch (Dali::DaliException e) {
86656       {
86657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86658       };
86659     } catch (...) {
86660       {
86661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86662       };
86663     }
86664   }
86665
86666
86667   //argout typemap for const std::string&
86668
86669 }
86670
86671
86672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86673   unsigned int jresult ;
86674   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86675   std::string *arg2 = 0 ;
86676   Dali::Property::Value *arg3 = 0 ;
86677   bool result;
86678
86679   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86680   if (!jarg2) {
86681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86682     return 0;
86683   }
86684   std::string arg2_str(jarg2);
86685   arg2 = &arg2_str;
86686   arg3 = (Dali::Property::Value *)jarg3;
86687   if (!arg3) {
86688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86689     return 0;
86690   }
86691   {
86692     try {
86693       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86694     } catch (std::out_of_range& e) {
86695       {
86696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86697       };
86698     } catch (std::exception& e) {
86699       {
86700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86701       };
86702     } catch (Dali::DaliException e) {
86703       {
86704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86705       };
86706     } catch (...) {
86707       {
86708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86709       };
86710     }
86711   }
86712
86713   jresult = result;
86714
86715   //argout typemap for const std::string&
86716
86717   return jresult;
86718 }
86719
86720
86721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86722   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86723   Dali::Toolkit::Control arg2 ;
86724   std::string *arg3 = 0 ;
86725   std::string *arg4 = 0 ;
86726   Dali::Toolkit::Control *argp2 ;
86727
86728   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86729   argp2 = (Dali::Toolkit::Control *)jarg2;
86730   if (!argp2) {
86731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86732     return ;
86733   }
86734   arg2 = *argp2;
86735   if (!jarg3) {
86736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86737     return ;
86738   }
86739   std::string arg3_str(jarg3);
86740   arg3 = &arg3_str;
86741   if (!jarg4) {
86742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86743     return ;
86744   }
86745   std::string arg4_str(jarg4);
86746   arg4 = &arg4_str;
86747   {
86748     try {
86749       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86750     } catch (std::out_of_range& e) {
86751       {
86752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86753       };
86754     } catch (std::exception& e) {
86755       {
86756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86757       };
86758     } catch (Dali::DaliException e) {
86759       {
86760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86761       };
86762     } catch (...) {
86763       {
86764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86765       };
86766     }
86767   }
86768
86769
86770   //argout typemap for const std::string&
86771
86772
86773   //argout typemap for const std::string&
86774
86775 }
86776
86777
86778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86779   void * jresult ;
86780   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86781   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86782
86783   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86784   {
86785     try {
86786       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86787     } catch (std::out_of_range& e) {
86788       {
86789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86790       };
86791     } catch (std::exception& e) {
86792       {
86793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86794       };
86795     } catch (Dali::DaliException e) {
86796       {
86797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86798       };
86799     } catch (...) {
86800       {
86801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86802       };
86803     }
86804   }
86805
86806   jresult = (void *)result;
86807   return jresult;
86808 }
86809
86810
86811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86812   int jresult ;
86813   int result;
86814
86815   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86816   jresult = (int)result;
86817   return jresult;
86818 }
86819
86820
86821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86822   int jresult ;
86823   int result;
86824
86825   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86826   jresult = (int)result;
86827   return jresult;
86828 }
86829
86830
86831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86832   int jresult ;
86833   int result;
86834
86835   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86836   jresult = (int)result;
86837   return jresult;
86838 }
86839
86840
86841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86842   int jresult ;
86843   int result;
86844
86845   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86846   jresult = (int)result;
86847   return jresult;
86848 }
86849
86850
86851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86852   int jresult ;
86853   int result;
86854
86855   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86856   jresult = (int)result;
86857   return jresult;
86858 }
86859
86860
86861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86862   int jresult ;
86863   int result;
86864
86865   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86866   jresult = (int)result;
86867   return jresult;
86868 }
86869
86870
86871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86872   int jresult ;
86873   int result;
86874
86875   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86876   jresult = (int)result;
86877   return jresult;
86878 }
86879
86880
86881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86882   int jresult ;
86883   int result;
86884
86885   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86886   jresult = (int)result;
86887   return jresult;
86888 }
86889
86890
86891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86892   int jresult ;
86893   int result;
86894
86895   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86896   jresult = (int)result;
86897   return jresult;
86898 }
86899
86900
86901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86902   int jresult ;
86903   int result;
86904
86905   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86906   jresult = (int)result;
86907   return jresult;
86908 }
86909
86910
86911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86912   int jresult ;
86913   int result;
86914
86915   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86916   jresult = (int)result;
86917   return jresult;
86918 }
86919
86920
86921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86922   int jresult ;
86923   int result;
86924
86925   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86926   jresult = (int)result;
86927   return jresult;
86928 }
86929
86930
86931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86932   int jresult ;
86933   int result;
86934
86935   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86936   jresult = (int)result;
86937   return jresult;
86938 }
86939
86940
86941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86942   int jresult ;
86943   int result;
86944
86945   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86946   jresult = (int)result;
86947   return jresult;
86948 }
86949
86950
86951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86952   int jresult ;
86953   int result;
86954
86955   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86956   jresult = (int)result;
86957   return jresult;
86958 }
86959
86960
86961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86962   void * jresult ;
86963   Dali::Toolkit::Slider::Property *result = 0 ;
86964
86965   {
86966     try {
86967       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86968     } catch (std::out_of_range& e) {
86969       {
86970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86971       };
86972     } catch (std::exception& e) {
86973       {
86974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86975       };
86976     } catch (Dali::DaliException e) {
86977       {
86978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86979       };
86980     } catch (...) {
86981       {
86982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86983       };
86984     }
86985   }
86986
86987   jresult = (void *)result;
86988   return jresult;
86989 }
86990
86991
86992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86993   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86994
86995   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86996   {
86997     try {
86998       delete arg1;
86999     } catch (std::out_of_range& e) {
87000       {
87001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87002       };
87003     } catch (std::exception& e) {
87004       {
87005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87006       };
87007     } catch (Dali::DaliException e) {
87008       {
87009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87010       };
87011     } catch (...) {
87012       {
87013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87014       };
87015     }
87016   }
87017
87018 }
87019
87020
87021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87022   void * jresult ;
87023   Dali::Toolkit::Slider result;
87024
87025   {
87026     try {
87027       result = Dali::Toolkit::Slider::New();
87028     } catch (std::out_of_range& e) {
87029       {
87030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87031       };
87032     } catch (std::exception& e) {
87033       {
87034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87035       };
87036     } catch (Dali::DaliException e) {
87037       {
87038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87039       };
87040     } catch (...) {
87041       {
87042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87043       };
87044     }
87045   }
87046
87047   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87048   return jresult;
87049 }
87050
87051
87052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87053   void * jresult ;
87054   Dali::Toolkit::Slider *result = 0 ;
87055
87056   {
87057     try {
87058       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87059     } catch (std::out_of_range& e) {
87060       {
87061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87062       };
87063     } catch (std::exception& e) {
87064       {
87065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87066       };
87067     } catch (Dali::DaliException e) {
87068       {
87069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87070       };
87071     } catch (...) {
87072       {
87073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87074       };
87075     }
87076   }
87077
87078   jresult = (void *)result;
87079   return jresult;
87080 }
87081
87082
87083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87084   void * jresult ;
87085   Dali::Toolkit::Slider *arg1 = 0 ;
87086   Dali::Toolkit::Slider *result = 0 ;
87087
87088   arg1 = (Dali::Toolkit::Slider *)jarg1;
87089   if (!arg1) {
87090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87091     return 0;
87092   }
87093   {
87094     try {
87095       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87096     } catch (std::out_of_range& e) {
87097       {
87098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87099       };
87100     } catch (std::exception& e) {
87101       {
87102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87103       };
87104     } catch (Dali::DaliException e) {
87105       {
87106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87107       };
87108     } catch (...) {
87109       {
87110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87111       };
87112     }
87113   }
87114
87115   jresult = (void *)result;
87116   return jresult;
87117 }
87118
87119
87120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87121   void * jresult ;
87122   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87123   Dali::Toolkit::Slider *arg2 = 0 ;
87124   Dali::Toolkit::Slider *result = 0 ;
87125
87126   arg1 = (Dali::Toolkit::Slider *)jarg1;
87127   arg2 = (Dali::Toolkit::Slider *)jarg2;
87128   if (!arg2) {
87129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87130     return 0;
87131   }
87132   {
87133     try {
87134       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87142       };
87143     } catch (Dali::DaliException e) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87146       };
87147     } catch (...) {
87148       {
87149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87150       };
87151     }
87152   }
87153
87154   jresult = (void *)result;
87155   return jresult;
87156 }
87157
87158
87159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87160   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87161
87162   arg1 = (Dali::Toolkit::Slider *)jarg1;
87163   {
87164     try {
87165       delete arg1;
87166     } catch (std::out_of_range& e) {
87167       {
87168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87169       };
87170     } catch (std::exception& e) {
87171       {
87172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87173       };
87174     } catch (Dali::DaliException e) {
87175       {
87176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87177       };
87178     } catch (...) {
87179       {
87180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87181       };
87182     }
87183   }
87184
87185 }
87186
87187
87188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87189   void * jresult ;
87190   Dali::BaseHandle arg1 ;
87191   Dali::BaseHandle *argp1 ;
87192   Dali::Toolkit::Slider result;
87193
87194   argp1 = (Dali::BaseHandle *)jarg1;
87195   if (!argp1) {
87196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87197     return 0;
87198   }
87199   arg1 = *argp1;
87200   {
87201     try {
87202       result = Dali::Toolkit::Slider::DownCast(arg1);
87203     } catch (std::out_of_range& e) {
87204       {
87205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87206       };
87207     } catch (std::exception& e) {
87208       {
87209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87210       };
87211     } catch (Dali::DaliException e) {
87212       {
87213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87214       };
87215     } catch (...) {
87216       {
87217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87218       };
87219     }
87220   }
87221
87222   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87223   return jresult;
87224 }
87225
87226
87227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87228   void * jresult ;
87229   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87230   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87231
87232   arg1 = (Dali::Toolkit::Slider *)jarg1;
87233   {
87234     try {
87235       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87236     } catch (std::out_of_range& e) {
87237       {
87238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87239       };
87240     } catch (std::exception& e) {
87241       {
87242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87243       };
87244     } catch (Dali::DaliException e) {
87245       {
87246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87247       };
87248     } catch (...) {
87249       {
87250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87251       };
87252     }
87253   }
87254
87255   jresult = (void *)result;
87256   return jresult;
87257 }
87258
87259
87260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87261   void * jresult ;
87262   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87263   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87264
87265   arg1 = (Dali::Toolkit::Slider *)jarg1;
87266   {
87267     try {
87268       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87269     } catch (std::out_of_range& e) {
87270       {
87271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87272       };
87273     } catch (std::exception& e) {
87274       {
87275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87276       };
87277     } catch (Dali::DaliException e) {
87278       {
87279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87280       };
87281     } catch (...) {
87282       {
87283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87284       };
87285     }
87286   }
87287
87288   jresult = (void *)result;
87289   return jresult;
87290 }
87291
87292
87293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87294   void * jresult ;
87295   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87296   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87297
87298   arg1 = (Dali::Toolkit::Slider *)jarg1;
87299   {
87300     try {
87301       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87302     } catch (std::out_of_range& e) {
87303       {
87304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87305       };
87306     } catch (std::exception& e) {
87307       {
87308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87309       };
87310     } catch (Dali::DaliException e) {
87311       {
87312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87313       };
87314     } catch (...) {
87315       {
87316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87317       };
87318     }
87319   }
87320
87321   jresult = (void *)result;
87322   return jresult;
87323 }
87324
87325
87326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87327   int jresult ;
87328   int result;
87329
87330   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87331   jresult = (int)result;
87332   return jresult;
87333 }
87334
87335
87336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87337   int jresult ;
87338   int result;
87339
87340   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87341   jresult = (int)result;
87342   return jresult;
87343 }
87344
87345
87346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87347   int jresult ;
87348   int result;
87349
87350   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87351   jresult = (int)result;
87352   return jresult;
87353 }
87354
87355
87356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87357   int jresult ;
87358   int result;
87359
87360   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87361   jresult = (int)result;
87362   return jresult;
87363 }
87364
87365
87366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87367   int result;
87368
87369   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87370
87371   return result;
87372 }
87373
87374
87375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87376   void * jresult ;
87377   Dali::Toolkit::VideoView::Property *result = 0 ;
87378
87379   {
87380     try {
87381       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87382     } catch (std::out_of_range& e) {
87383       {
87384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87385       };
87386     } catch (std::exception& e) {
87387       {
87388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87389       };
87390     } catch (Dali::DaliException e) {
87391       {
87392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87393       };
87394     } catch (...) {
87395       {
87396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87397       };
87398     }
87399   }
87400
87401   jresult = (void *)result;
87402   return jresult;
87403 }
87404
87405
87406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87407   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87408
87409   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87410   {
87411     try {
87412       delete arg1;
87413     } catch (std::out_of_range& e) {
87414       {
87415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87416       };
87417     } catch (std::exception& e) {
87418       {
87419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87420       };
87421     } catch (Dali::DaliException e) {
87422       {
87423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87424       };
87425     } catch (...) {
87426       {
87427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87428       };
87429     }
87430   }
87431
87432 }
87433
87434
87435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87436   void * jresult ;
87437   Dali::Toolkit::VideoView result;
87438
87439   {
87440     try {
87441       result = Dali::Toolkit::VideoView::New();
87442     } catch (std::out_of_range& e) {
87443       {
87444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87445       };
87446     } catch (std::exception& e) {
87447       {
87448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87449       };
87450     } catch (Dali::DaliException e) {
87451       {
87452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87453       };
87454     } catch (...) {
87455       {
87456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87457       };
87458     }
87459   }
87460
87461   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87462   return jresult;
87463 }
87464
87465
87466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87467   void * jresult ;
87468   std::string *arg1 = 0 ;
87469   Dali::Toolkit::VideoView result;
87470
87471   if (!jarg1) {
87472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87473     return 0;
87474   }
87475   std::string arg1_str(jarg1);
87476   arg1 = &arg1_str;
87477   {
87478     try {
87479       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87480     } catch (std::out_of_range& e) {
87481       {
87482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87483       };
87484     } catch (std::exception& e) {
87485       {
87486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87487       };
87488     } catch (Dali::DaliException e) {
87489       {
87490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87491       };
87492     } catch (...) {
87493       {
87494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87495       };
87496     }
87497   }
87498
87499   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87500
87501   //argout typemap for const std::string&
87502
87503   return jresult;
87504 }
87505
87506
87507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87508   void * jresult ;
87509   Dali::Toolkit::VideoView *result = 0 ;
87510
87511   {
87512     try {
87513       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87514     } catch (std::out_of_range& e) {
87515       {
87516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87517       };
87518     } catch (std::exception& e) {
87519       {
87520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87521       };
87522     } catch (Dali::DaliException e) {
87523       {
87524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87525       };
87526     } catch (...) {
87527       {
87528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87529       };
87530     }
87531   }
87532
87533   jresult = (void *)result;
87534   return jresult;
87535 }
87536
87537
87538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87539   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87540
87541   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87542   {
87543     try {
87544       delete arg1;
87545     } catch (std::out_of_range& e) {
87546       {
87547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87548       };
87549     } catch (std::exception& e) {
87550       {
87551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87552       };
87553     } catch (Dali::DaliException e) {
87554       {
87555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87556       };
87557     } catch (...) {
87558       {
87559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87560       };
87561     }
87562   }
87563
87564 }
87565
87566
87567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87568   void * jresult ;
87569   Dali::Toolkit::VideoView *arg1 = 0 ;
87570   Dali::Toolkit::VideoView *result = 0 ;
87571
87572   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87573   if (!arg1) {
87574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87575     return 0;
87576   }
87577   {
87578     try {
87579       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87580     } catch (std::out_of_range& e) {
87581       {
87582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87583       };
87584     } catch (std::exception& e) {
87585       {
87586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87587       };
87588     } catch (Dali::DaliException e) {
87589       {
87590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87591       };
87592     } catch (...) {
87593       {
87594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87595       };
87596     }
87597   }
87598
87599   jresult = (void *)result;
87600   return jresult;
87601 }
87602
87603
87604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87605   void * jresult ;
87606   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87607   Dali::Toolkit::VideoView *arg2 = 0 ;
87608   Dali::Toolkit::VideoView *result = 0 ;
87609
87610   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87611   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87612   if (!arg2) {
87613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87614     return 0;
87615   }
87616   {
87617     try {
87618       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87619     } catch (std::out_of_range& e) {
87620       {
87621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87622       };
87623     } catch (std::exception& e) {
87624       {
87625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87626       };
87627     } catch (Dali::DaliException e) {
87628       {
87629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87630       };
87631     } catch (...) {
87632       {
87633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87634       };
87635     }
87636   }
87637
87638   jresult = (void *)result;
87639   return jresult;
87640 }
87641
87642
87643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87644   void * jresult ;
87645   Dali::BaseHandle arg1 ;
87646   Dali::BaseHandle *argp1 ;
87647   Dali::Toolkit::VideoView result;
87648
87649   argp1 = (Dali::BaseHandle *)jarg1;
87650   if (!argp1) {
87651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87652     return 0;
87653   }
87654   arg1 = *argp1;
87655   {
87656     try {
87657       result = Dali::Toolkit::VideoView::DownCast(arg1);
87658     } catch (std::out_of_range& e) {
87659       {
87660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87661       };
87662     } catch (std::exception& e) {
87663       {
87664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87665       };
87666     } catch (Dali::DaliException e) {
87667       {
87668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87669       };
87670     } catch (...) {
87671       {
87672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87673       };
87674     }
87675   }
87676
87677   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87678   return jresult;
87679 }
87680
87681
87682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87683   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87684
87685   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87686   {
87687     try {
87688       (arg1)->Play();
87689     } catch (std::out_of_range& e) {
87690       {
87691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87692       };
87693     } catch (std::exception& e) {
87694       {
87695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87696       };
87697     } catch (Dali::DaliException e) {
87698       {
87699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87700       };
87701     } catch (...) {
87702       {
87703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87704       };
87705     }
87706   }
87707
87708 }
87709
87710
87711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87712   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87713
87714   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87715   {
87716     try {
87717       (arg1)->Pause();
87718     } catch (std::out_of_range& e) {
87719       {
87720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87721       };
87722     } catch (std::exception& e) {
87723       {
87724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87725       };
87726     } catch (Dali::DaliException e) {
87727       {
87728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87729       };
87730     } catch (...) {
87731       {
87732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87733       };
87734     }
87735   }
87736
87737 }
87738
87739
87740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87741   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87742
87743   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87744   {
87745     try {
87746       (arg1)->Stop();
87747     } catch (std::out_of_range& e) {
87748       {
87749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87750       };
87751     } catch (std::exception& e) {
87752       {
87753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87754       };
87755     } catch (Dali::DaliException e) {
87756       {
87757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87758       };
87759     } catch (...) {
87760       {
87761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87762       };
87763     }
87764   }
87765
87766 }
87767
87768
87769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87770   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87771   int arg2 ;
87772
87773   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87774   arg2 = (int)jarg2;
87775   {
87776     try {
87777       (arg1)->Forward(arg2);
87778     } catch (std::out_of_range& e) {
87779       {
87780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87781       };
87782     } catch (std::exception& e) {
87783       {
87784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87785       };
87786     } catch (Dali::DaliException e) {
87787       {
87788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87789       };
87790     } catch (...) {
87791       {
87792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87793       };
87794     }
87795   }
87796
87797 }
87798
87799
87800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87801   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87802   int arg2 ;
87803
87804   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87805   arg2 = (int)jarg2;
87806   {
87807     try {
87808       (arg1)->Backward(arg2);
87809     } catch (std::out_of_range& e) {
87810       {
87811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87812       };
87813     } catch (std::exception& e) {
87814       {
87815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87816       };
87817     } catch (Dali::DaliException e) {
87818       {
87819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87820       };
87821     } catch (...) {
87822       {
87823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87824       };
87825     }
87826   }
87827
87828 }
87829
87830
87831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87832   void * jresult ;
87833   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87834   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87835
87836   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87837   {
87838     try {
87839       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87840     } catch (std::out_of_range& e) {
87841       {
87842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87843       };
87844     } catch (std::exception& e) {
87845       {
87846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87847       };
87848     } catch (Dali::DaliException e) {
87849       {
87850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87851       };
87852     } catch (...) {
87853       {
87854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87855       };
87856     }
87857   }
87858
87859   jresult = (void *)result;
87860   return jresult;
87861 }
87862
87863
87864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87865   int jresult ;
87866   int result;
87867
87868   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87869   jresult = (int)result;
87870   return jresult;
87871 }
87872
87873
87874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87875   int jresult ;
87876   int result;
87877
87878   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87879   jresult = (int)result;
87880   return jresult;
87881 }
87882
87883
87884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87885   int jresult ;
87886   int result;
87887
87888   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87889   jresult = (int)result;
87890   return jresult;
87891 }
87892
87893
87894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87895   int jresult ;
87896   int result;
87897
87898   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87899   jresult = (int)result;
87900   return jresult;
87901 }
87902
87903
87904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87905   int jresult ;
87906   int result;
87907
87908   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87909   jresult = (int)result;
87910   return jresult;
87911 }
87912
87913
87914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87915   int jresult ;
87916   int result;
87917
87918   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87919   jresult = (int)result;
87920   return jresult;
87921 }
87922
87923
87924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87925   int jresult ;
87926   int result;
87927
87928   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87929   jresult = (int)result;
87930   return jresult;
87931 }
87932
87933
87934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87935   int jresult ;
87936   int result;
87937
87938   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87939   jresult = (int)result;
87940   return jresult;
87941 }
87942
87943
87944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87945   int jresult ;
87946   int result;
87947
87948   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87949   jresult = (int)result;
87950   return jresult;
87951 }
87952
87953
87954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87955   int jresult ;
87956   int result;
87957
87958   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87959   jresult = (int)result;
87960   return jresult;
87961 }
87962
87963
87964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87965   int jresult ;
87966   int result;
87967
87968   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87969   jresult = (int)result;
87970   return jresult;
87971 }
87972
87973
87974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87975   int jresult ;
87976   int result;
87977
87978   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87979   jresult = (int)result;
87980   return jresult;
87981 }
87982
87983
87984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87985   int jresult ;
87986   int result;
87987
87988   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87989   jresult = (int)result;
87990   return jresult;
87991 }
87992
87993
87994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87995   int jresult ;
87996   int result;
87997
87998   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87999   jresult = (int)result;
88000   return jresult;
88001 }
88002
88003
88004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88005   int jresult ;
88006   int result;
88007
88008   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88009   jresult = (int)result;
88010   return jresult;
88011 }
88012
88013
88014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88015   int jresult ;
88016   int result;
88017
88018   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88019   jresult = (int)result;
88020   return jresult;
88021 }
88022
88023
88024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88025   int jresult ;
88026   int result;
88027
88028   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88029   jresult = (int)result;
88030   return jresult;
88031 }
88032
88033
88034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88035   int jresult ;
88036   int result;
88037
88038   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88039   jresult = (int)result;
88040   return jresult;
88041 }
88042
88043
88044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88045   int jresult ;
88046   int result;
88047
88048   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88049   jresult = (int)result;
88050   return jresult;
88051 }
88052
88053
88054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88055   int jresult ;
88056   int result;
88057
88058   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88059   jresult = (int)result;
88060   return jresult;
88061 }
88062
88063
88064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88065   int jresult ;
88066   int result;
88067
88068   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88069   jresult = (int)result;
88070   return jresult;
88071 }
88072
88073
88074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88075   void * jresult ;
88076   Dali::Toolkit::Popup::Property *result = 0 ;
88077
88078   {
88079     try {
88080       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88081     } catch (std::out_of_range& e) {
88082       {
88083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88084       };
88085     } catch (std::exception& e) {
88086       {
88087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88088       };
88089     } catch (Dali::DaliException e) {
88090       {
88091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88092       };
88093     } catch (...) {
88094       {
88095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88096       };
88097     }
88098   }
88099
88100   jresult = (void *)result;
88101   return jresult;
88102 }
88103
88104
88105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88106   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88107
88108   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88109   {
88110     try {
88111       delete arg1;
88112     } catch (std::out_of_range& e) {
88113       {
88114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88115       };
88116     } catch (std::exception& e) {
88117       {
88118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88119       };
88120     } catch (Dali::DaliException e) {
88121       {
88122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88123       };
88124     } catch (...) {
88125       {
88126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88127       };
88128     }
88129   }
88130
88131 }
88132
88133
88134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88135   void * jresult ;
88136   Dali::Toolkit::Popup *result = 0 ;
88137
88138   {
88139     try {
88140       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88141     } catch (std::out_of_range& e) {
88142       {
88143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88144       };
88145     } catch (std::exception& e) {
88146       {
88147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88148       };
88149     } catch (Dali::DaliException e) {
88150       {
88151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88152       };
88153     } catch (...) {
88154       {
88155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88156       };
88157     }
88158   }
88159
88160   jresult = (void *)result;
88161   return jresult;
88162 }
88163
88164
88165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88166   void * jresult ;
88167   Dali::Toolkit::Popup result;
88168
88169   {
88170     try {
88171       result = Dali::Toolkit::Popup::New();
88172     } catch (std::out_of_range& e) {
88173       {
88174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88175       };
88176     } catch (std::exception& e) {
88177       {
88178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88179       };
88180     } catch (Dali::DaliException e) {
88181       {
88182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88183       };
88184     } catch (...) {
88185       {
88186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88187       };
88188     }
88189   }
88190
88191   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88192   return jresult;
88193 }
88194
88195
88196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88197   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88198
88199   arg1 = (Dali::Toolkit::Popup *)jarg1;
88200   {
88201     try {
88202       delete arg1;
88203     } catch (std::out_of_range& e) {
88204       {
88205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88206       };
88207     } catch (std::exception& e) {
88208       {
88209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88210       };
88211     } catch (Dali::DaliException e) {
88212       {
88213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88214       };
88215     } catch (...) {
88216       {
88217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88218       };
88219     }
88220   }
88221
88222 }
88223
88224
88225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88226   void * jresult ;
88227   Dali::Toolkit::Popup *arg1 = 0 ;
88228   Dali::Toolkit::Popup *result = 0 ;
88229
88230   arg1 = (Dali::Toolkit::Popup *)jarg1;
88231   if (!arg1) {
88232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88233     return 0;
88234   }
88235   {
88236     try {
88237       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88238     } catch (std::out_of_range& e) {
88239       {
88240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88241       };
88242     } catch (std::exception& e) {
88243       {
88244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88245       };
88246     } catch (Dali::DaliException e) {
88247       {
88248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88249       };
88250     } catch (...) {
88251       {
88252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88253       };
88254     }
88255   }
88256
88257   jresult = (void *)result;
88258   return jresult;
88259 }
88260
88261
88262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88263   void * jresult ;
88264   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88265   Dali::Toolkit::Popup *arg2 = 0 ;
88266   Dali::Toolkit::Popup *result = 0 ;
88267
88268   arg1 = (Dali::Toolkit::Popup *)jarg1;
88269   arg2 = (Dali::Toolkit::Popup *)jarg2;
88270   if (!arg2) {
88271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88272     return 0;
88273   }
88274   {
88275     try {
88276       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88292       };
88293     }
88294   }
88295
88296   jresult = (void *)result;
88297   return jresult;
88298 }
88299
88300
88301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88302   void * jresult ;
88303   Dali::BaseHandle arg1 ;
88304   Dali::BaseHandle *argp1 ;
88305   Dali::Toolkit::Popup result;
88306
88307   argp1 = (Dali::BaseHandle *)jarg1;
88308   if (!argp1) {
88309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88310     return 0;
88311   }
88312   arg1 = *argp1;
88313   {
88314     try {
88315       result = Dali::Toolkit::Popup::DownCast(arg1);
88316     } catch (std::out_of_range& e) {
88317       {
88318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88319       };
88320     } catch (std::exception& e) {
88321       {
88322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88323       };
88324     } catch (Dali::DaliException e) {
88325       {
88326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88327       };
88328     } catch (...) {
88329       {
88330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88331       };
88332     }
88333   }
88334
88335   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88336   return jresult;
88337 }
88338
88339
88340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88341   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88342   Dali::Actor arg2 ;
88343   Dali::Actor *argp2 ;
88344
88345   arg1 = (Dali::Toolkit::Popup *)jarg1;
88346   argp2 = (Dali::Actor *)jarg2;
88347   if (!argp2) {
88348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88349     return ;
88350   }
88351   arg2 = *argp2;
88352   {
88353     try {
88354       (arg1)->SetTitle(arg2);
88355     } catch (std::out_of_range& e) {
88356       {
88357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88358       };
88359     } catch (std::exception& e) {
88360       {
88361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88362       };
88363     } catch (Dali::DaliException e) {
88364       {
88365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88366       };
88367     } catch (...) {
88368       {
88369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88370       };
88371     }
88372   }
88373
88374 }
88375
88376
88377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88378   void * jresult ;
88379   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88380   Dali::Actor result;
88381
88382   arg1 = (Dali::Toolkit::Popup *)jarg1;
88383   {
88384     try {
88385       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88386     } catch (std::out_of_range& e) {
88387       {
88388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88389       };
88390     } catch (std::exception& e) {
88391       {
88392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88393       };
88394     } catch (Dali::DaliException e) {
88395       {
88396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88397       };
88398     } catch (...) {
88399       {
88400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88401       };
88402     }
88403   }
88404
88405   jresult = new Dali::Actor((const Dali::Actor &)result);
88406   return jresult;
88407 }
88408
88409
88410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88411   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88412   Dali::Actor arg2 ;
88413   Dali::Actor *argp2 ;
88414
88415   arg1 = (Dali::Toolkit::Popup *)jarg1;
88416   argp2 = (Dali::Actor *)jarg2;
88417   if (!argp2) {
88418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88419     return ;
88420   }
88421   arg2 = *argp2;
88422   {
88423     try {
88424       (arg1)->SetContent(arg2);
88425     } catch (std::out_of_range& e) {
88426       {
88427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88428       };
88429     } catch (std::exception& e) {
88430       {
88431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88432       };
88433     } catch (Dali::DaliException e) {
88434       {
88435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88436       };
88437     } catch (...) {
88438       {
88439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88440       };
88441     }
88442   }
88443
88444 }
88445
88446
88447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88448   void * jresult ;
88449   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88450   Dali::Actor result;
88451
88452   arg1 = (Dali::Toolkit::Popup *)jarg1;
88453   {
88454     try {
88455       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88456     } catch (std::out_of_range& e) {
88457       {
88458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88459       };
88460     } catch (std::exception& e) {
88461       {
88462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88463       };
88464     } catch (Dali::DaliException e) {
88465       {
88466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88467       };
88468     } catch (...) {
88469       {
88470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88471       };
88472     }
88473   }
88474
88475   jresult = new Dali::Actor((const Dali::Actor &)result);
88476   return jresult;
88477 }
88478
88479
88480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88481   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88482   Dali::Actor arg2 ;
88483   Dali::Actor *argp2 ;
88484
88485   arg1 = (Dali::Toolkit::Popup *)jarg1;
88486   argp2 = (Dali::Actor *)jarg2;
88487   if (!argp2) {
88488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88489     return ;
88490   }
88491   arg2 = *argp2;
88492   {
88493     try {
88494       (arg1)->SetFooter(arg2);
88495     } catch (std::out_of_range& e) {
88496       {
88497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88498       };
88499     } catch (std::exception& e) {
88500       {
88501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88502       };
88503     } catch (Dali::DaliException e) {
88504       {
88505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88506       };
88507     } catch (...) {
88508       {
88509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88510       };
88511     }
88512   }
88513
88514 }
88515
88516
88517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88518   void * jresult ;
88519   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88520   Dali::Actor result;
88521
88522   arg1 = (Dali::Toolkit::Popup *)jarg1;
88523   {
88524     try {
88525       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88526     } catch (std::out_of_range& e) {
88527       {
88528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88529       };
88530     } catch (std::exception& e) {
88531       {
88532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88533       };
88534     } catch (Dali::DaliException e) {
88535       {
88536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88537       };
88538     } catch (...) {
88539       {
88540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88541       };
88542     }
88543   }
88544
88545   jresult = new Dali::Actor((const Dali::Actor &)result);
88546   return jresult;
88547 }
88548
88549
88550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88551   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88552   Dali::Toolkit::Popup::DisplayState arg2 ;
88553
88554   arg1 = (Dali::Toolkit::Popup *)jarg1;
88555   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88556   {
88557     try {
88558       (arg1)->SetDisplayState(arg2);
88559     } catch (std::out_of_range& e) {
88560       {
88561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88562       };
88563     } catch (std::exception& e) {
88564       {
88565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88566       };
88567     } catch (Dali::DaliException e) {
88568       {
88569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88570       };
88571     } catch (...) {
88572       {
88573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88574       };
88575     }
88576   }
88577
88578 }
88579
88580
88581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88582   int jresult ;
88583   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88584   Dali::Toolkit::Popup::DisplayState result;
88585
88586   arg1 = (Dali::Toolkit::Popup *)jarg1;
88587   {
88588     try {
88589       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88590     } catch (std::out_of_range& e) {
88591       {
88592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88593       };
88594     } catch (std::exception& e) {
88595       {
88596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88597       };
88598     } catch (Dali::DaliException e) {
88599       {
88600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88601       };
88602     } catch (...) {
88603       {
88604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88605       };
88606     }
88607   }
88608
88609   jresult = (int)result;
88610   return jresult;
88611 }
88612
88613
88614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88615   void * jresult ;
88616   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88617   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88618
88619   arg1 = (Dali::Toolkit::Popup *)jarg1;
88620   {
88621     try {
88622       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88623     } catch (std::out_of_range& e) {
88624       {
88625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88626       };
88627     } catch (std::exception& e) {
88628       {
88629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88630       };
88631     } catch (Dali::DaliException e) {
88632       {
88633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88634       };
88635     } catch (...) {
88636       {
88637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88638       };
88639     }
88640   }
88641
88642   jresult = (void *)result;
88643   return jresult;
88644 }
88645
88646
88647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88648   void * jresult ;
88649   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88650   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88651
88652   arg1 = (Dali::Toolkit::Popup *)jarg1;
88653   {
88654     try {
88655       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88656     } catch (std::out_of_range& e) {
88657       {
88658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88659       };
88660     } catch (std::exception& e) {
88661       {
88662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88663       };
88664     } catch (Dali::DaliException e) {
88665       {
88666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88667       };
88668     } catch (...) {
88669       {
88670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88671       };
88672     }
88673   }
88674
88675   jresult = (void *)result;
88676   return jresult;
88677 }
88678
88679
88680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88681   void * jresult ;
88682   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88683   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88684
88685   arg1 = (Dali::Toolkit::Popup *)jarg1;
88686   {
88687     try {
88688       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88689     } catch (std::out_of_range& e) {
88690       {
88691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88692       };
88693     } catch (std::exception& e) {
88694       {
88695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88696       };
88697     } catch (Dali::DaliException e) {
88698       {
88699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88700       };
88701     } catch (...) {
88702       {
88703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88704       };
88705     }
88706   }
88707
88708   jresult = (void *)result;
88709   return jresult;
88710 }
88711
88712
88713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88714   void * jresult ;
88715   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88716   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88717
88718   arg1 = (Dali::Toolkit::Popup *)jarg1;
88719   {
88720     try {
88721       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88722     } catch (std::out_of_range& e) {
88723       {
88724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88725       };
88726     } catch (std::exception& e) {
88727       {
88728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88729       };
88730     } catch (Dali::DaliException e) {
88731       {
88732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88733       };
88734     } catch (...) {
88735       {
88736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88737       };
88738     }
88739   }
88740
88741   jresult = (void *)result;
88742   return jresult;
88743 }
88744
88745
88746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88747   void * jresult ;
88748   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88749   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88750
88751   arg1 = (Dali::Toolkit::Popup *)jarg1;
88752   {
88753     try {
88754       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88755     } catch (std::out_of_range& e) {
88756       {
88757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88758       };
88759     } catch (std::exception& e) {
88760       {
88761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88762       };
88763     } catch (Dali::DaliException e) {
88764       {
88765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88766       };
88767     } catch (...) {
88768       {
88769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88770       };
88771     }
88772   }
88773
88774   jresult = (void *)result;
88775   return jresult;
88776 }
88777
88778
88779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88780   int jresult ;
88781   int result;
88782
88783   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88784   jresult = (int)result;
88785   return jresult;
88786 }
88787
88788
88789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88790   int jresult ;
88791   int result;
88792
88793   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88794   jresult = (int)result;
88795   return jresult;
88796 }
88797
88798
88799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88800   int jresult ;
88801   int result;
88802
88803   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88804   jresult = (int)result;
88805   return jresult;
88806 }
88807
88808
88809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88810   int jresult ;
88811   int result;
88812
88813   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88814   jresult = (int)result;
88815   return jresult;
88816 }
88817
88818
88819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88820   int jresult ;
88821   int result;
88822
88823   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88824   jresult = (int)result;
88825   return jresult;
88826 }
88827
88828
88829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88830   int jresult ;
88831   int result;
88832
88833   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88834   jresult = (int)result;
88835   return jresult;
88836 }
88837
88838
88839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88840   int jresult ;
88841   int result;
88842
88843   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88844   jresult = (int)result;
88845   return jresult;
88846 }
88847
88848
88849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88850   int jresult ;
88851   int result;
88852
88853   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88854   jresult = (int)result;
88855   return jresult;
88856 }
88857
88858
88859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88860   int jresult ;
88861   int result;
88862
88863   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88864   jresult = (int)result;
88865   return jresult;
88866 }
88867
88868
88869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88870   void * jresult ;
88871   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88872
88873   {
88874     try {
88875       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88876     } catch (std::out_of_range& e) {
88877       {
88878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88879       };
88880     } catch (std::exception& e) {
88881       {
88882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88883       };
88884     } catch (Dali::DaliException e) {
88885       {
88886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88887       };
88888     } catch (...) {
88889       {
88890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88891       };
88892     }
88893   }
88894
88895   jresult = (void *)result;
88896   return jresult;
88897 }
88898
88899
88900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88901   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88902
88903   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88904   {
88905     try {
88906       delete arg1;
88907     } catch (std::out_of_range& e) {
88908       {
88909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88910       };
88911     } catch (std::exception& e) {
88912       {
88913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88914       };
88915     } catch (Dali::DaliException e) {
88916       {
88917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88918       };
88919     } catch (...) {
88920       {
88921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88922       };
88923     }
88924   }
88925
88926 }
88927
88928
88929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88930   void * jresult ;
88931   Dali::Toolkit::ProgressBar result;
88932
88933   {
88934     try {
88935       result = Dali::Toolkit::ProgressBar::New();
88936     } catch (std::out_of_range& e) {
88937       {
88938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88939       };
88940     } catch (std::exception& e) {
88941       {
88942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88943       };
88944     } catch (Dali::DaliException e) {
88945       {
88946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88947       };
88948     } catch (...) {
88949       {
88950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88951       };
88952     }
88953   }
88954
88955   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88956   return jresult;
88957 }
88958
88959
88960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88961   void * jresult ;
88962   Dali::Toolkit::ProgressBar *result = 0 ;
88963
88964   {
88965     try {
88966       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88967     } catch (std::out_of_range& e) {
88968       {
88969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88970       };
88971     } catch (std::exception& e) {
88972       {
88973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88974       };
88975     } catch (Dali::DaliException e) {
88976       {
88977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88978       };
88979     } catch (...) {
88980       {
88981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88982       };
88983     }
88984   }
88985
88986   jresult = (void *)result;
88987   return jresult;
88988 }
88989
88990
88991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88992   void * jresult ;
88993   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88994   Dali::Toolkit::ProgressBar *result = 0 ;
88995
88996   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88997   if (!arg1) {
88998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88999     return 0;
89000   }
89001   {
89002     try {
89003       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89004     } catch (std::out_of_range& e) {
89005       {
89006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89007       };
89008     } catch (std::exception& e) {
89009       {
89010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89011       };
89012     } catch (Dali::DaliException e) {
89013       {
89014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89015       };
89016     } catch (...) {
89017       {
89018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89019       };
89020     }
89021   }
89022
89023   jresult = (void *)result;
89024   return jresult;
89025 }
89026
89027
89028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89029   void * jresult ;
89030   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89031   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89032   Dali::Toolkit::ProgressBar *result = 0 ;
89033
89034   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89035   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89036   if (!arg2) {
89037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89038     return 0;
89039   }
89040   {
89041     try {
89042       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89043     } catch (std::out_of_range& e) {
89044       {
89045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89046       };
89047     } catch (std::exception& e) {
89048       {
89049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89050       };
89051     } catch (Dali::DaliException e) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89054       };
89055     } catch (...) {
89056       {
89057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89058       };
89059     }
89060   }
89061
89062   jresult = (void *)result;
89063   return jresult;
89064 }
89065
89066
89067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89068   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89069
89070   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89071   {
89072     try {
89073       delete arg1;
89074     } catch (std::out_of_range& e) {
89075       {
89076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89077       };
89078     } catch (std::exception& e) {
89079       {
89080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89081       };
89082     } catch (Dali::DaliException e) {
89083       {
89084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89085       };
89086     } catch (...) {
89087       {
89088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89089       };
89090     }
89091   }
89092
89093 }
89094
89095
89096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89097   void * jresult ;
89098   Dali::BaseHandle arg1 ;
89099   Dali::BaseHandle *argp1 ;
89100   Dali::Toolkit::ProgressBar result;
89101
89102   argp1 = (Dali::BaseHandle *)jarg1;
89103   if (!argp1) {
89104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89105     return 0;
89106   }
89107   arg1 = *argp1;
89108   {
89109     try {
89110       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89111     } catch (std::out_of_range& e) {
89112       {
89113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89114       };
89115     } catch (std::exception& e) {
89116       {
89117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89118       };
89119     } catch (Dali::DaliException e) {
89120       {
89121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89122       };
89123     } catch (...) {
89124       {
89125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89126       };
89127     }
89128   }
89129
89130   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89131   return jresult;
89132 }
89133
89134
89135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89136   void * jresult ;
89137   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89138   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89139
89140   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89141   {
89142     try {
89143       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89144     } catch (std::out_of_range& e) {
89145       {
89146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89147       };
89148     } catch (std::exception& e) {
89149       {
89150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89151       };
89152     } catch (Dali::DaliException e) {
89153       {
89154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89155       };
89156     } catch (...) {
89157       {
89158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89159       };
89160     }
89161   }
89162
89163   jresult = (void *)result;
89164   return jresult;
89165 }
89166
89167
89168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89169   void * jresult ;
89170   Dali::Toolkit::GaussianBlurView *result = 0 ;
89171
89172   {
89173     try {
89174       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89175     } catch (std::out_of_range& e) {
89176       {
89177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89178       };
89179     } catch (std::exception& e) {
89180       {
89181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89182       };
89183     } catch (Dali::DaliException e) {
89184       {
89185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89186       };
89187     } catch (...) {
89188       {
89189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89190       };
89191     }
89192   }
89193
89194   jresult = (void *)result;
89195   return jresult;
89196 }
89197
89198
89199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89200   void * jresult ;
89201   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89202   Dali::Toolkit::GaussianBlurView *result = 0 ;
89203
89204   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89205   if (!arg1) {
89206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89207     return 0;
89208   }
89209   {
89210     try {
89211       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89212     } catch (std::out_of_range& e) {
89213       {
89214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89215       };
89216     } catch (std::exception& e) {
89217       {
89218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89219       };
89220     } catch (Dali::DaliException e) {
89221       {
89222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89223       };
89224     } catch (...) {
89225       {
89226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89227       };
89228     }
89229   }
89230
89231   jresult = (void *)result;
89232   return jresult;
89233 }
89234
89235
89236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89237   void * jresult ;
89238   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89239   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89240   Dali::Toolkit::GaussianBlurView *result = 0 ;
89241
89242   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89243   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89244   if (!arg2) {
89245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89246     return 0;
89247   }
89248   {
89249     try {
89250       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89251     } catch (std::out_of_range& e) {
89252       {
89253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89254       };
89255     } catch (std::exception& e) {
89256       {
89257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89258       };
89259     } catch (Dali::DaliException e) {
89260       {
89261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89262       };
89263     } catch (...) {
89264       {
89265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89266       };
89267     }
89268   }
89269
89270   jresult = (void *)result;
89271   return jresult;
89272 }
89273
89274
89275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89276   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89277
89278   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89279   {
89280     try {
89281       delete arg1;
89282     } catch (std::out_of_range& e) {
89283       {
89284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89285       };
89286     } catch (std::exception& e) {
89287       {
89288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89289       };
89290     } catch (Dali::DaliException e) {
89291       {
89292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89293       };
89294     } catch (...) {
89295       {
89296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89297       };
89298     }
89299   }
89300
89301 }
89302
89303
89304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89305   void * jresult ;
89306   Dali::BaseHandle arg1 ;
89307   Dali::BaseHandle *argp1 ;
89308   Dali::Toolkit::GaussianBlurView result;
89309
89310   argp1 = (Dali::BaseHandle *)jarg1;
89311   if (!argp1) {
89312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89313     return 0;
89314   }
89315   arg1 = *argp1;
89316   {
89317     try {
89318       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89319     } catch (std::out_of_range& e) {
89320       {
89321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89322       };
89323     } catch (std::exception& e) {
89324       {
89325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89326       };
89327     } catch (Dali::DaliException e) {
89328       {
89329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89330       };
89331     } catch (...) {
89332       {
89333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89334       };
89335     }
89336   }
89337
89338   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89339   return jresult;
89340 }
89341
89342
89343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89344   void * jresult ;
89345   Dali::Toolkit::GaussianBlurView result;
89346
89347   {
89348     try {
89349       result = Dali::Toolkit::GaussianBlurView::New();
89350     } catch (std::out_of_range& e) {
89351       {
89352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89353       };
89354     } catch (std::exception& e) {
89355       {
89356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89357       };
89358     } catch (Dali::DaliException e) {
89359       {
89360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89361       };
89362     } catch (...) {
89363       {
89364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89365       };
89366     }
89367   }
89368
89369   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89370   return jresult;
89371 }
89372
89373
89374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89375   void * jresult ;
89376   unsigned int arg1 ;
89377   float arg2 ;
89378   Dali::Pixel::Format arg3 ;
89379   float arg4 ;
89380   float arg5 ;
89381   bool arg6 ;
89382   Dali::Toolkit::GaussianBlurView result;
89383
89384   arg1 = (unsigned int)jarg1;
89385   arg2 = (float)jarg2;
89386   arg3 = (Dali::Pixel::Format)jarg3;
89387   arg4 = (float)jarg4;
89388   arg5 = (float)jarg5;
89389   arg6 = jarg6 ? true : false;
89390   {
89391     try {
89392       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89393     } catch (std::out_of_range& e) {
89394       {
89395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89396       };
89397     } catch (std::exception& e) {
89398       {
89399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89400       };
89401     } catch (Dali::DaliException e) {
89402       {
89403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89404       };
89405     } catch (...) {
89406       {
89407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89408       };
89409     }
89410   }
89411
89412   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89413   return jresult;
89414 }
89415
89416
89417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89418   void * jresult ;
89419   unsigned int arg1 ;
89420   float arg2 ;
89421   Dali::Pixel::Format arg3 ;
89422   float arg4 ;
89423   float arg5 ;
89424   Dali::Toolkit::GaussianBlurView result;
89425
89426   arg1 = (unsigned int)jarg1;
89427   arg2 = (float)jarg2;
89428   arg3 = (Dali::Pixel::Format)jarg3;
89429   arg4 = (float)jarg4;
89430   arg5 = (float)jarg5;
89431   {
89432     try {
89433       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89434     } catch (std::out_of_range& e) {
89435       {
89436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89437       };
89438     } catch (std::exception& e) {
89439       {
89440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89441       };
89442     } catch (Dali::DaliException e) {
89443       {
89444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89445       };
89446     } catch (...) {
89447       {
89448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89449       };
89450     }
89451   }
89452
89453   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89454   return jresult;
89455 }
89456
89457
89458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89459   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89460   Dali::Actor arg2 ;
89461   Dali::Actor *argp2 ;
89462
89463   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89464   argp2 = (Dali::Actor *)jarg2;
89465   if (!argp2) {
89466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89467     return ;
89468   }
89469   arg2 = *argp2;
89470   {
89471     try {
89472       (arg1)->Add(arg2);
89473     } catch (std::out_of_range& e) {
89474       {
89475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89476       };
89477     } catch (std::exception& e) {
89478       {
89479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89480       };
89481     } catch (Dali::DaliException e) {
89482       {
89483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89484       };
89485     } catch (...) {
89486       {
89487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89488       };
89489     }
89490   }
89491
89492 }
89493
89494
89495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89496   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89497   Dali::Actor arg2 ;
89498   Dali::Actor *argp2 ;
89499
89500   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89501   argp2 = (Dali::Actor *)jarg2;
89502   if (!argp2) {
89503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89504     return ;
89505   }
89506   arg2 = *argp2;
89507   {
89508     try {
89509       (arg1)->Remove(arg2);
89510     } catch (std::out_of_range& e) {
89511       {
89512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89513       };
89514     } catch (std::exception& e) {
89515       {
89516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89517       };
89518     } catch (Dali::DaliException e) {
89519       {
89520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89521       };
89522     } catch (...) {
89523       {
89524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89525       };
89526     }
89527   }
89528
89529 }
89530
89531
89532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89533   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89534
89535   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89536   {
89537     try {
89538       (arg1)->Activate();
89539     } catch (std::out_of_range& e) {
89540       {
89541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89542       };
89543     } catch (std::exception& e) {
89544       {
89545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89546       };
89547     } catch (Dali::DaliException e) {
89548       {
89549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89550       };
89551     } catch (...) {
89552       {
89553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89554       };
89555     }
89556   }
89557
89558 }
89559
89560
89561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89562   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89563
89564   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89565   {
89566     try {
89567       (arg1)->ActivateOnce();
89568     } catch (std::out_of_range& e) {
89569       {
89570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89571       };
89572     } catch (std::exception& e) {
89573       {
89574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89575       };
89576     } catch (Dali::DaliException e) {
89577       {
89578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89579       };
89580     } catch (...) {
89581       {
89582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89583       };
89584     }
89585   }
89586
89587 }
89588
89589
89590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89591   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89592
89593   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89594   {
89595     try {
89596       (arg1)->Deactivate();
89597     } catch (std::out_of_range& e) {
89598       {
89599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89600       };
89601     } catch (std::exception& e) {
89602       {
89603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89604       };
89605     } catch (Dali::DaliException e) {
89606       {
89607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89608       };
89609     } catch (...) {
89610       {
89611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89612       };
89613     }
89614   }
89615
89616 }
89617
89618
89619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89620   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89621   Dali::Image arg2 ;
89622   Dali::FrameBufferImage arg3 ;
89623   Dali::Image *argp2 ;
89624   Dali::FrameBufferImage *argp3 ;
89625
89626   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89627   argp2 = (Dali::Image *)jarg2;
89628   if (!argp2) {
89629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89630     return ;
89631   }
89632   arg2 = *argp2;
89633   argp3 = (Dali::FrameBufferImage *)jarg3;
89634   if (!argp3) {
89635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89636     return ;
89637   }
89638   arg3 = *argp3;
89639   {
89640     try {
89641       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89642     } catch (std::out_of_range& e) {
89643       {
89644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89645       };
89646     } catch (std::exception& e) {
89647       {
89648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89649       };
89650     } catch (Dali::DaliException e) {
89651       {
89652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89653       };
89654     } catch (...) {
89655       {
89656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89657       };
89658     }
89659   }
89660
89661 }
89662
89663
89664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89665   int jresult ;
89666   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89667   Dali::Property::Index result;
89668
89669   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89670   {
89671     try {
89672       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89673     } catch (std::out_of_range& e) {
89674       {
89675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89676       };
89677     } catch (std::exception& e) {
89678       {
89679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89680       };
89681     } catch (Dali::DaliException e) {
89682       {
89683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89684       };
89685     } catch (...) {
89686       {
89687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89688       };
89689     }
89690   }
89691
89692   jresult = result;
89693   return jresult;
89694 }
89695
89696
89697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89698   void * jresult ;
89699   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89700   Dali::FrameBufferImage result;
89701
89702   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89703   {
89704     try {
89705       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89706     } catch (std::out_of_range& e) {
89707       {
89708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89709       };
89710     } catch (std::exception& e) {
89711       {
89712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89713       };
89714     } catch (Dali::DaliException e) {
89715       {
89716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89717       };
89718     } catch (...) {
89719       {
89720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89721       };
89722     }
89723   }
89724
89725   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89726   return jresult;
89727 }
89728
89729
89730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89731   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89732   Dali::Vector4 *arg2 = 0 ;
89733
89734   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89735   arg2 = (Dali::Vector4 *)jarg2;
89736   if (!arg2) {
89737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89738     return ;
89739   }
89740   {
89741     try {
89742       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89743     } catch (std::out_of_range& e) {
89744       {
89745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89746       };
89747     } catch (std::exception& e) {
89748       {
89749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89750       };
89751     } catch (Dali::DaliException e) {
89752       {
89753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89754       };
89755     } catch (...) {
89756       {
89757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89758       };
89759     }
89760   }
89761
89762 }
89763
89764
89765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89766   void * jresult ;
89767   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89768   Dali::Vector4 result;
89769
89770   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89771   {
89772     try {
89773       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89774     } catch (std::out_of_range& e) {
89775       {
89776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89777       };
89778     } catch (std::exception& e) {
89779       {
89780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89781       };
89782     } catch (Dali::DaliException e) {
89783       {
89784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89785       };
89786     } catch (...) {
89787       {
89788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89789       };
89790     }
89791   }
89792
89793   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89794   return jresult;
89795 }
89796
89797
89798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89799   void * jresult ;
89800   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89801   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89802
89803   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89804   {
89805     try {
89806       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89807     } catch (std::out_of_range& e) {
89808       {
89809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89810       };
89811     } catch (std::exception& e) {
89812       {
89813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89814       };
89815     } catch (Dali::DaliException e) {
89816       {
89817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89818       };
89819     } catch (...) {
89820       {
89821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89822       };
89823     }
89824   }
89825
89826   jresult = (void *)result;
89827   return jresult;
89828 }
89829
89830
89831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89832   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89833
89834   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89835   {
89836     try {
89837       delete arg1;
89838     } catch (std::out_of_range& e) {
89839       {
89840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89841       };
89842     } catch (std::exception& e) {
89843       {
89844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89845       };
89846     } catch (Dali::DaliException e) {
89847       {
89848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89849       };
89850     } catch (...) {
89851       {
89852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89853       };
89854     }
89855   }
89856
89857 }
89858
89859
89860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89861   unsigned int jresult ;
89862   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89863   unsigned int result;
89864
89865   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89866   {
89867     try {
89868       result = (unsigned int)(arg1)->GetNumberOfPages();
89869     } catch (std::out_of_range& e) {
89870       {
89871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89872       };
89873     } catch (std::exception& e) {
89874       {
89875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89876       };
89877     } catch (Dali::DaliException e) {
89878       {
89879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89880       };
89881     } catch (...) {
89882       {
89883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89884       };
89885     }
89886   }
89887
89888   jresult = result;
89889   return jresult;
89890 }
89891
89892
89893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89894   void * jresult ;
89895   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89896   unsigned int arg2 ;
89897   Dali::Texture result;
89898
89899   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89900   arg2 = (unsigned int)jarg2;
89901   {
89902     try {
89903       result = (arg1)->NewPage(arg2);
89904     } catch (std::out_of_range& e) {
89905       {
89906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89907       };
89908     } catch (std::exception& e) {
89909       {
89910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89911       };
89912     } catch (Dali::DaliException e) {
89913       {
89914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89915       };
89916     } catch (...) {
89917       {
89918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89919       };
89920     }
89921   }
89922
89923   jresult = new Dali::Texture((const Dali::Texture &)result);
89924   return jresult;
89925 }
89926
89927
89928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89929   int jresult ;
89930   int result;
89931
89932   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89933   jresult = (int)result;
89934   return jresult;
89935 }
89936
89937
89938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89939   int jresult ;
89940   int result;
89941
89942   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89943   jresult = (int)result;
89944   return jresult;
89945 }
89946
89947
89948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89949   int jresult ;
89950   int result;
89951
89952   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89953   jresult = (int)result;
89954   return jresult;
89955 }
89956
89957
89958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89959   void * jresult ;
89960   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89961
89962   {
89963     try {
89964       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89965     } catch (std::out_of_range& e) {
89966       {
89967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89968       };
89969     } catch (std::exception& e) {
89970       {
89971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89972       };
89973     } catch (Dali::DaliException e) {
89974       {
89975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89976       };
89977     } catch (...) {
89978       {
89979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89980       };
89981     }
89982   }
89983
89984   jresult = (void *)result;
89985   return jresult;
89986 }
89987
89988
89989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89990   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89991
89992   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89993   {
89994     try {
89995       delete arg1;
89996     } catch (std::out_of_range& e) {
89997       {
89998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89999       };
90000     } catch (std::exception& e) {
90001       {
90002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90003       };
90004     } catch (Dali::DaliException e) {
90005       {
90006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90007       };
90008     } catch (...) {
90009       {
90010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90011       };
90012     }
90013   }
90014
90015 }
90016
90017
90018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90019   void * jresult ;
90020   Dali::Toolkit::PageTurnView *result = 0 ;
90021
90022   {
90023     try {
90024       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90025     } catch (std::out_of_range& e) {
90026       {
90027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90028       };
90029     } catch (std::exception& e) {
90030       {
90031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90032       };
90033     } catch (Dali::DaliException e) {
90034       {
90035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90036       };
90037     } catch (...) {
90038       {
90039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90040       };
90041     }
90042   }
90043
90044   jresult = (void *)result;
90045   return jresult;
90046 }
90047
90048
90049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90050   void * jresult ;
90051   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90052   Dali::Toolkit::PageTurnView *result = 0 ;
90053
90054   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90055   if (!arg1) {
90056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90057     return 0;
90058   }
90059   {
90060     try {
90061       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90062     } catch (std::out_of_range& e) {
90063       {
90064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90065       };
90066     } catch (std::exception& e) {
90067       {
90068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90069       };
90070     } catch (Dali::DaliException e) {
90071       {
90072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90073       };
90074     } catch (...) {
90075       {
90076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90077       };
90078     }
90079   }
90080
90081   jresult = (void *)result;
90082   return jresult;
90083 }
90084
90085
90086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90087   void * jresult ;
90088   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90089   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90090   Dali::Toolkit::PageTurnView *result = 0 ;
90091
90092   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90093   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90094   if (!arg2) {
90095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90096     return 0;
90097   }
90098   {
90099     try {
90100       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90101     } catch (std::out_of_range& e) {
90102       {
90103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90104       };
90105     } catch (std::exception& e) {
90106       {
90107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90108       };
90109     } catch (Dali::DaliException e) {
90110       {
90111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90112       };
90113     } catch (...) {
90114       {
90115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90116       };
90117     }
90118   }
90119
90120   jresult = (void *)result;
90121   return jresult;
90122 }
90123
90124
90125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90126   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90127
90128   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90129   {
90130     try {
90131       delete arg1;
90132     } catch (std::out_of_range& e) {
90133       {
90134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90135       };
90136     } catch (std::exception& e) {
90137       {
90138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90139       };
90140     } catch (Dali::DaliException e) {
90141       {
90142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90143       };
90144     } catch (...) {
90145       {
90146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90147       };
90148     }
90149   }
90150
90151 }
90152
90153
90154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90155   void * jresult ;
90156   Dali::BaseHandle arg1 ;
90157   Dali::BaseHandle *argp1 ;
90158   Dali::Toolkit::PageTurnView result;
90159
90160   argp1 = (Dali::BaseHandle *)jarg1;
90161   if (!argp1) {
90162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90163     return 0;
90164   }
90165   arg1 = *argp1;
90166   {
90167     try {
90168       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90169     } catch (std::out_of_range& e) {
90170       {
90171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90172       };
90173     } catch (std::exception& e) {
90174       {
90175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90176       };
90177     } catch (Dali::DaliException e) {
90178       {
90179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90180       };
90181     } catch (...) {
90182       {
90183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90184       };
90185     }
90186   }
90187
90188   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90189   return jresult;
90190 }
90191
90192
90193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90194   void * jresult ;
90195   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90196   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90197
90198   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90199   {
90200     try {
90201       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90202     } catch (std::out_of_range& e) {
90203       {
90204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90205       };
90206     } catch (std::exception& e) {
90207       {
90208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90209       };
90210     } catch (Dali::DaliException e) {
90211       {
90212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90213       };
90214     } catch (...) {
90215       {
90216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90217       };
90218     }
90219   }
90220
90221   jresult = (void *)result;
90222   return jresult;
90223 }
90224
90225
90226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90227   void * jresult ;
90228   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90229   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90230
90231   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90232   {
90233     try {
90234       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90235     } catch (std::out_of_range& e) {
90236       {
90237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90238       };
90239     } catch (std::exception& e) {
90240       {
90241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90242       };
90243     } catch (Dali::DaliException e) {
90244       {
90245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90246       };
90247     } catch (...) {
90248       {
90249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90250       };
90251     }
90252   }
90253
90254   jresult = (void *)result;
90255   return jresult;
90256 }
90257
90258
90259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90260   void * jresult ;
90261   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90262   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90263
90264   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90265   {
90266     try {
90267       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90268     } catch (std::out_of_range& e) {
90269       {
90270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90271       };
90272     } catch (std::exception& e) {
90273       {
90274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90275       };
90276     } catch (Dali::DaliException e) {
90277       {
90278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90279       };
90280     } catch (...) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90283       };
90284     }
90285   }
90286
90287   jresult = (void *)result;
90288   return jresult;
90289 }
90290
90291
90292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90293   void * jresult ;
90294   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90295   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90296
90297   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90298   {
90299     try {
90300       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90301     } catch (std::out_of_range& e) {
90302       {
90303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90304       };
90305     } catch (std::exception& e) {
90306       {
90307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90308       };
90309     } catch (Dali::DaliException e) {
90310       {
90311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90312       };
90313     } catch (...) {
90314       {
90315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90316       };
90317     }
90318   }
90319
90320   jresult = (void *)result;
90321   return jresult;
90322 }
90323
90324
90325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90326   void * jresult ;
90327   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90328
90329   {
90330     try {
90331       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90332     } catch (std::out_of_range& e) {
90333       {
90334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90335       };
90336     } catch (std::exception& e) {
90337       {
90338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90339       };
90340     } catch (Dali::DaliException e) {
90341       {
90342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90343       };
90344     } catch (...) {
90345       {
90346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90347       };
90348     }
90349   }
90350
90351   jresult = (void *)result;
90352   return jresult;
90353 }
90354
90355
90356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90357   void * jresult ;
90358   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90359   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90360
90361   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90362   if (!arg1) {
90363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90364     return 0;
90365   }
90366   {
90367     try {
90368       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90369     } catch (std::out_of_range& e) {
90370       {
90371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90372       };
90373     } catch (std::exception& e) {
90374       {
90375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90376       };
90377     } catch (Dali::DaliException e) {
90378       {
90379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90380       };
90381     } catch (...) {
90382       {
90383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90384       };
90385     }
90386   }
90387
90388   jresult = (void *)result;
90389   return jresult;
90390 }
90391
90392
90393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90394   void * jresult ;
90395   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90396   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90397   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90398
90399   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90400   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90401   if (!arg2) {
90402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90403     return 0;
90404   }
90405   {
90406     try {
90407       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90408     } catch (std::out_of_range& e) {
90409       {
90410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90411       };
90412     } catch (std::exception& e) {
90413       {
90414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90415       };
90416     } catch (Dali::DaliException e) {
90417       {
90418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90419       };
90420     } catch (...) {
90421       {
90422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90423       };
90424     }
90425   }
90426
90427   jresult = (void *)result;
90428   return jresult;
90429 }
90430
90431
90432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90433   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90434
90435   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90436   {
90437     try {
90438       delete arg1;
90439     } catch (std::out_of_range& e) {
90440       {
90441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90442       };
90443     } catch (std::exception& e) {
90444       {
90445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90446       };
90447     } catch (Dali::DaliException e) {
90448       {
90449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90450       };
90451     } catch (...) {
90452       {
90453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90454       };
90455     }
90456   }
90457
90458 }
90459
90460
90461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90462   void * jresult ;
90463   Dali::Toolkit::PageFactory *arg1 = 0 ;
90464   Dali::Vector2 *arg2 = 0 ;
90465   Dali::Toolkit::PageTurnLandscapeView result;
90466
90467   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90468   if (!arg1) {
90469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90470     return 0;
90471   }
90472   arg2 = (Dali::Vector2 *)jarg2;
90473   if (!arg2) {
90474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90475     return 0;
90476   }
90477   {
90478     try {
90479       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90480     } catch (std::out_of_range& e) {
90481       {
90482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90483       };
90484     } catch (std::exception& e) {
90485       {
90486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90487       };
90488     } catch (Dali::DaliException e) {
90489       {
90490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90491       };
90492     } catch (...) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90495       };
90496     }
90497   }
90498
90499   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90500   return jresult;
90501 }
90502
90503
90504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90505   void * jresult ;
90506   Dali::BaseHandle arg1 ;
90507   Dali::BaseHandle *argp1 ;
90508   Dali::Toolkit::PageTurnLandscapeView result;
90509
90510   argp1 = (Dali::BaseHandle *)jarg1;
90511   if (!argp1) {
90512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90513     return 0;
90514   }
90515   arg1 = *argp1;
90516   {
90517     try {
90518       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90519     } catch (std::out_of_range& e) {
90520       {
90521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90522       };
90523     } catch (std::exception& e) {
90524       {
90525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90526       };
90527     } catch (Dali::DaliException e) {
90528       {
90529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90530       };
90531     } catch (...) {
90532       {
90533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90534       };
90535     }
90536   }
90537
90538   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90539   return jresult;
90540 }
90541
90542
90543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90544   void * jresult ;
90545   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90546
90547   {
90548     try {
90549       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90550     } catch (std::out_of_range& e) {
90551       {
90552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90553       };
90554     } catch (std::exception& e) {
90555       {
90556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90557       };
90558     } catch (Dali::DaliException e) {
90559       {
90560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90561       };
90562     } catch (...) {
90563       {
90564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90565       };
90566     }
90567   }
90568
90569   jresult = (void *)result;
90570   return jresult;
90571 }
90572
90573
90574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90575   void * jresult ;
90576   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90577   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90578
90579   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90580   if (!arg1) {
90581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90582     return 0;
90583   }
90584   {
90585     try {
90586       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90587     } catch (std::out_of_range& e) {
90588       {
90589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90590       };
90591     } catch (std::exception& e) {
90592       {
90593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90594       };
90595     } catch (Dali::DaliException e) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90598       };
90599     } catch (...) {
90600       {
90601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90602       };
90603     }
90604   }
90605
90606   jresult = (void *)result;
90607   return jresult;
90608 }
90609
90610
90611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90612   void * jresult ;
90613   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90614   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90615   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90616
90617   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90618   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90619   if (!arg2) {
90620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90621     return 0;
90622   }
90623   {
90624     try {
90625       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90626     } catch (std::out_of_range& e) {
90627       {
90628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90629       };
90630     } catch (std::exception& e) {
90631       {
90632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90633       };
90634     } catch (Dali::DaliException e) {
90635       {
90636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90637       };
90638     } catch (...) {
90639       {
90640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90641       };
90642     }
90643   }
90644
90645   jresult = (void *)result;
90646   return jresult;
90647 }
90648
90649
90650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90651   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90652
90653   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90654   {
90655     try {
90656       delete arg1;
90657     } catch (std::out_of_range& e) {
90658       {
90659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90660       };
90661     } catch (std::exception& e) {
90662       {
90663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90664       };
90665     } catch (Dali::DaliException e) {
90666       {
90667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90668       };
90669     } catch (...) {
90670       {
90671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90672       };
90673     }
90674   }
90675
90676 }
90677
90678
90679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90680   void * jresult ;
90681   Dali::Toolkit::PageFactory *arg1 = 0 ;
90682   Dali::Vector2 *arg2 = 0 ;
90683   Dali::Toolkit::PageTurnPortraitView result;
90684
90685   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90686   if (!arg1) {
90687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90688     return 0;
90689   }
90690   arg2 = (Dali::Vector2 *)jarg2;
90691   if (!arg2) {
90692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90693     return 0;
90694   }
90695   {
90696     try {
90697       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90698     } catch (std::out_of_range& e) {
90699       {
90700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90701       };
90702     } catch (std::exception& e) {
90703       {
90704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90705       };
90706     } catch (Dali::DaliException e) {
90707       {
90708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90709       };
90710     } catch (...) {
90711       {
90712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90713       };
90714     }
90715   }
90716
90717   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90718   return jresult;
90719 }
90720
90721
90722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90723   void * jresult ;
90724   Dali::BaseHandle arg1 ;
90725   Dali::BaseHandle *argp1 ;
90726   Dali::Toolkit::PageTurnPortraitView result;
90727
90728   argp1 = (Dali::BaseHandle *)jarg1;
90729   if (!argp1) {
90730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90731     return 0;
90732   }
90733   arg1 = *argp1;
90734   {
90735     try {
90736       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90737     } catch (std::out_of_range& e) {
90738       {
90739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90740       };
90741     } catch (std::exception& e) {
90742       {
90743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90744       };
90745     } catch (Dali::DaliException e) {
90746       {
90747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90748       };
90749     } catch (...) {
90750       {
90751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90752       };
90753     }
90754   }
90755
90756   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90757   return jresult;
90758 }
90759
90760
90761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90762   int jresult ;
90763   int result;
90764
90765   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90766   jresult = (int)result;
90767   return jresult;
90768 }
90769
90770
90771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90772   int jresult ;
90773   int result;
90774
90775   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90776   jresult = (int)result;
90777   return jresult;
90778 }
90779
90780
90781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90782   int jresult ;
90783   int result;
90784
90785   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90786   jresult = (int)result;
90787   return jresult;
90788 }
90789
90790
90791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90792   void * jresult ;
90793   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90794
90795   {
90796     try {
90797       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90798     } catch (std::out_of_range& e) {
90799       {
90800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90801       };
90802     } catch (std::exception& e) {
90803       {
90804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90805       };
90806     } catch (Dali::DaliException e) {
90807       {
90808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90809       };
90810     } catch (...) {
90811       {
90812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90813       };
90814     }
90815   }
90816
90817   jresult = (void *)result;
90818   return jresult;
90819 }
90820
90821
90822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90823   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90824
90825   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90826   {
90827     try {
90828       delete arg1;
90829     } catch (std::out_of_range& e) {
90830       {
90831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90832       };
90833     } catch (std::exception& e) {
90834       {
90835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90836       };
90837     } catch (Dali::DaliException e) {
90838       {
90839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90840       };
90841     } catch (...) {
90842       {
90843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90844       };
90845     }
90846   }
90847
90848 }
90849
90850
90851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90852   void * jresult ;
90853   Dali::Toolkit::ToggleButton *result = 0 ;
90854
90855   {
90856     try {
90857       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90858     } catch (std::out_of_range& e) {
90859       {
90860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90861       };
90862     } catch (std::exception& e) {
90863       {
90864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90865       };
90866     } catch (Dali::DaliException e) {
90867       {
90868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90869       };
90870     } catch (...) {
90871       {
90872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90873       };
90874     }
90875   }
90876
90877   jresult = (void *)result;
90878   return jresult;
90879 }
90880
90881
90882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90883   void * jresult ;
90884   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90885   Dali::Toolkit::ToggleButton *result = 0 ;
90886
90887   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90888   if (!arg1) {
90889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90890     return 0;
90891   }
90892   {
90893     try {
90894       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90895     } catch (std::out_of_range& e) {
90896       {
90897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90898       };
90899     } catch (std::exception& e) {
90900       {
90901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90902       };
90903     } catch (Dali::DaliException e) {
90904       {
90905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90906       };
90907     } catch (...) {
90908       {
90909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90910       };
90911     }
90912   }
90913
90914   jresult = (void *)result;
90915   return jresult;
90916 }
90917
90918
90919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90920   void * jresult ;
90921   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90922   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90923   Dali::Toolkit::ToggleButton *result = 0 ;
90924
90925   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90926   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90927   if (!arg2) {
90928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90929     return 0;
90930   }
90931   {
90932     try {
90933       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90934     } catch (std::out_of_range& e) {
90935       {
90936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90937       };
90938     } catch (std::exception& e) {
90939       {
90940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90941       };
90942     } catch (Dali::DaliException e) {
90943       {
90944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90945       };
90946     } catch (...) {
90947       {
90948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90949       };
90950     }
90951   }
90952
90953   jresult = (void *)result;
90954   return jresult;
90955 }
90956
90957
90958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90959   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90960
90961   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90962   {
90963     try {
90964       delete arg1;
90965     } catch (std::out_of_range& e) {
90966       {
90967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90968       };
90969     } catch (std::exception& e) {
90970       {
90971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90972       };
90973     } catch (Dali::DaliException e) {
90974       {
90975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90976       };
90977     } catch (...) {
90978       {
90979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90980       };
90981     }
90982   }
90983
90984 }
90985
90986
90987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90988   void * jresult ;
90989   Dali::Toolkit::ToggleButton result;
90990
90991   {
90992     try {
90993       result = Dali::Toolkit::ToggleButton::New();
90994     } catch (std::out_of_range& e) {
90995       {
90996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90997       };
90998     } catch (std::exception& e) {
90999       {
91000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91001       };
91002     } catch (Dali::DaliException e) {
91003       {
91004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91005       };
91006     } catch (...) {
91007       {
91008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91009       };
91010     }
91011   }
91012
91013   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91014   return jresult;
91015 }
91016
91017
91018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91019   void * jresult ;
91020   Dali::BaseHandle arg1 ;
91021   Dali::BaseHandle *argp1 ;
91022   Dali::Toolkit::ToggleButton result;
91023
91024   argp1 = (Dali::BaseHandle *)jarg1;
91025   if (!argp1) {
91026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91027     return 0;
91028   }
91029   arg1 = *argp1;
91030   {
91031     try {
91032       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91033     } catch (std::out_of_range& e) {
91034       {
91035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91036       };
91037     } catch (std::exception& e) {
91038       {
91039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91040       };
91041     } catch (Dali::DaliException e) {
91042       {
91043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91044       };
91045     } catch (...) {
91046       {
91047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91048       };
91049     }
91050   }
91051
91052   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91053   return jresult;
91054 }
91055
91056
91057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91058   void * jresult ;
91059   Dali::Toolkit::Visual::Base *result = 0 ;
91060
91061   {
91062     try {
91063       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91064     } catch (std::out_of_range& e) {
91065       {
91066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91067       };
91068     } catch (std::exception& e) {
91069       {
91070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91071       };
91072     } catch (Dali::DaliException e) {
91073       {
91074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91075       };
91076     } catch (...) {
91077       {
91078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91079       };
91080     }
91081   }
91082
91083   jresult = (void *)result;
91084   return jresult;
91085 }
91086
91087
91088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91089   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91090
91091   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91092   {
91093     try {
91094       delete arg1;
91095     } catch (std::out_of_range& e) {
91096       {
91097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91098       };
91099     } catch (std::exception& e) {
91100       {
91101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91102       };
91103     } catch (Dali::DaliException e) {
91104       {
91105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91106       };
91107     } catch (...) {
91108       {
91109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91110       };
91111     }
91112   }
91113
91114 }
91115
91116
91117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91118   void * jresult ;
91119   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91120   Dali::Toolkit::Visual::Base *result = 0 ;
91121
91122   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91123   if (!arg1) {
91124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91125     return 0;
91126   }
91127   {
91128     try {
91129       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91130     } catch (std::out_of_range& e) {
91131       {
91132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91133       };
91134     } catch (std::exception& e) {
91135       {
91136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91137       };
91138     } catch (Dali::DaliException e) {
91139       {
91140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91141       };
91142     } catch (...) {
91143       {
91144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91145       };
91146     }
91147   }
91148
91149   jresult = (void *)result;
91150   return jresult;
91151 }
91152
91153
91154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91155   void * jresult ;
91156   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91157   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91158   Dali::Toolkit::Visual::Base *result = 0 ;
91159
91160   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91161   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91162   if (!arg2) {
91163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91164     return 0;
91165   }
91166   {
91167     try {
91168       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91169     } catch (std::out_of_range& e) {
91170       {
91171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91172       };
91173     } catch (std::exception& e) {
91174       {
91175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91176       };
91177     } catch (Dali::DaliException e) {
91178       {
91179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91180       };
91181     } catch (...) {
91182       {
91183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91184       };
91185     }
91186   }
91187
91188   jresult = (void *)result;
91189   return jresult;
91190 }
91191
91192
91193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91194   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91195   std::string *arg2 = 0 ;
91196
91197   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91198   if (!jarg2) {
91199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91200     return ;
91201   }
91202   std::string arg2_str(jarg2);
91203   arg2 = &arg2_str;
91204   {
91205     try {
91206       (arg1)->SetName((std::string const &)*arg2);
91207     } catch (std::out_of_range& e) {
91208       {
91209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91210       };
91211     } catch (std::exception& e) {
91212       {
91213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91214       };
91215     } catch (Dali::DaliException e) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91218       };
91219     } catch (...) {
91220       {
91221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91222       };
91223     }
91224   }
91225
91226
91227   //argout typemap for const std::string&
91228
91229 }
91230
91231
91232 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91233   char * jresult ;
91234   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91235   std::string *result = 0 ;
91236
91237   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91238   {
91239     try {
91240       result = (std::string *) &(arg1)->GetName();
91241     } catch (std::out_of_range& e) {
91242       {
91243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91244       };
91245     } catch (std::exception& e) {
91246       {
91247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91248       };
91249     } catch (Dali::DaliException e) {
91250       {
91251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91252       };
91253     } catch (...) {
91254       {
91255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91256       };
91257     }
91258   }
91259
91260   jresult = SWIG_csharp_string_callback(result->c_str());
91261   return jresult;
91262 }
91263
91264
91265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91266   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91267   Dali::Property::Map *arg2 = 0 ;
91268   Dali::Size arg3 ;
91269   Dali::Size *argp3 ;
91270
91271   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91272   arg2 = (Dali::Property::Map *)jarg2;
91273   if (!arg2) {
91274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91275     return ;
91276   }
91277   argp3 = (Dali::Size *)jarg3;
91278   if (!argp3) {
91279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91280     return ;
91281   }
91282   arg3 = *argp3;
91283   {
91284     try {
91285       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91286     } catch (std::out_of_range& e) {
91287       {
91288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91289       };
91290     } catch (std::exception& e) {
91291       {
91292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91293       };
91294     } catch (Dali::DaliException e) {
91295       {
91296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91297       };
91298     } catch (...) {
91299       {
91300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91301       };
91302     }
91303   }
91304
91305 }
91306
91307
91308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91309   float jresult ;
91310   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91311   float arg2 ;
91312   float result;
91313
91314   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91315   arg2 = (float)jarg2;
91316   {
91317     try {
91318       result = (float)(arg1)->GetHeightForWidth(arg2);
91319     } catch (std::out_of_range& e) {
91320       {
91321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91322       };
91323     } catch (std::exception& e) {
91324       {
91325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91326       };
91327     } catch (Dali::DaliException e) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91330       };
91331     } catch (...) {
91332       {
91333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91334       };
91335     }
91336   }
91337
91338   jresult = result;
91339   return jresult;
91340 }
91341
91342
91343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91344   float jresult ;
91345   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91346   float arg2 ;
91347   float result;
91348
91349   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91350   arg2 = (float)jarg2;
91351   {
91352     try {
91353       result = (float)(arg1)->GetWidthForHeight(arg2);
91354     } catch (std::out_of_range& e) {
91355       {
91356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91357       };
91358     } catch (std::exception& e) {
91359       {
91360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91361       };
91362     } catch (Dali::DaliException e) {
91363       {
91364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91365       };
91366     } catch (...) {
91367       {
91368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91369       };
91370     }
91371   }
91372
91373   jresult = result;
91374   return jresult;
91375 }
91376
91377
91378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91379   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91380   Dali::Vector2 *arg2 = 0 ;
91381
91382   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91383   arg2 = (Dali::Vector2 *)jarg2;
91384   if (!arg2) {
91385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91386     return ;
91387   }
91388   {
91389     try {
91390       (arg1)->GetNaturalSize(*arg2);
91391     } catch (std::out_of_range& e) {
91392       {
91393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91394       };
91395     } catch (std::exception& e) {
91396       {
91397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91398       };
91399     } catch (Dali::DaliException e) {
91400       {
91401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91402       };
91403     } catch (...) {
91404       {
91405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91406       };
91407     }
91408   }
91409
91410 }
91411
91412
91413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91414   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91415   float arg2 ;
91416
91417   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91418   arg2 = (int)jarg2;
91419   {
91420     try {
91421       (arg1)->SetDepthIndex(arg2);
91422     } catch (std::out_of_range& e) {
91423       {
91424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91425       };
91426     } catch (std::exception& e) {
91427       {
91428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91429       };
91430     } catch (Dali::DaliException e) {
91431       {
91432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91433       };
91434     } catch (...) {
91435       {
91436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91437       };
91438     }
91439   }
91440
91441 }
91442
91443
91444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91445   int jresult ;
91446   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91447   int result;
91448
91449   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91450   {
91451     try {
91452       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91453     } catch (std::out_of_range& e) {
91454       {
91455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91456       };
91457     } catch (std::exception& e) {
91458       {
91459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91460       };
91461     } catch (Dali::DaliException e) {
91462       {
91463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91464       };
91465     } catch (...) {
91466       {
91467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91468       };
91469     }
91470   }
91471
91472   jresult = result;
91473   return jresult;
91474 }
91475
91476
91477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91478   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91479   Dali::Property::Map *arg2 = 0 ;
91480
91481   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91482   arg2 = (Dali::Property::Map *)jarg2;
91483   if (!arg2) {
91484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91485     return ;
91486   }
91487   {
91488     try {
91489       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91490     } catch (std::out_of_range& e) {
91491       {
91492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91493       };
91494     } catch (std::exception& e) {
91495       {
91496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91497       };
91498     } catch (Dali::DaliException e) {
91499       {
91500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91501       };
91502     } catch (...) {
91503       {
91504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91505       };
91506     }
91507   }
91508
91509 }
91510
91511
91512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91513   void * jresult ;
91514   Dali::Toolkit::VisualFactory result;
91515
91516   {
91517     try {
91518       result = Dali::Toolkit::VisualFactory::Get();
91519     } catch (std::out_of_range& e) {
91520       {
91521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91522       };
91523     } catch (std::exception& e) {
91524       {
91525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91526       };
91527     } catch (Dali::DaliException e) {
91528       {
91529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91530       };
91531     } catch (...) {
91532       {
91533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91534       };
91535     }
91536   }
91537
91538   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91539   return jresult;
91540 }
91541
91542
91543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91544   void * jresult ;
91545   Dali::Toolkit::VisualFactory *result = 0 ;
91546
91547   {
91548     try {
91549       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91550     } catch (std::out_of_range& e) {
91551       {
91552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91553       };
91554     } catch (std::exception& e) {
91555       {
91556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91557       };
91558     } catch (Dali::DaliException e) {
91559       {
91560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91561       };
91562     } catch (...) {
91563       {
91564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91565       };
91566     }
91567   }
91568
91569   jresult = (void *)result;
91570   return jresult;
91571 }
91572
91573
91574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91575   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91576
91577   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91578   {
91579     try {
91580       delete arg1;
91581     } catch (std::out_of_range& e) {
91582       {
91583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91584       };
91585     } catch (std::exception& e) {
91586       {
91587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91588       };
91589     } catch (Dali::DaliException e) {
91590       {
91591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91592       };
91593     } catch (...) {
91594       {
91595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91596       };
91597     }
91598   }
91599
91600 }
91601
91602
91603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91604   void * jresult ;
91605   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91606   Dali::Toolkit::VisualFactory *result = 0 ;
91607
91608   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91609   if (!arg1) {
91610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91611     return 0;
91612   }
91613   {
91614     try {
91615       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91616     } catch (std::out_of_range& e) {
91617       {
91618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91619       };
91620     } catch (std::exception& e) {
91621       {
91622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91623       };
91624     } catch (Dali::DaliException e) {
91625       {
91626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91627       };
91628     } catch (...) {
91629       {
91630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91631       };
91632     }
91633   }
91634
91635   jresult = (void *)result;
91636   return jresult;
91637 }
91638
91639
91640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91641   void * jresult ;
91642   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91643   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91644   Dali::Toolkit::VisualFactory *result = 0 ;
91645
91646   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91647   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91648   if (!arg2) {
91649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91650     return 0;
91651   }
91652   {
91653     try {
91654       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91655     } catch (std::out_of_range& e) {
91656       {
91657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91658       };
91659     } catch (std::exception& e) {
91660       {
91661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91662       };
91663     } catch (Dali::DaliException e) {
91664       {
91665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91666       };
91667     } catch (...) {
91668       {
91669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91670       };
91671     }
91672   }
91673
91674   jresult = (void *)result;
91675   return jresult;
91676 }
91677
91678
91679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91680   void * jresult ;
91681   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91682   Dali::Property::Map *arg2 = 0 ;
91683   Dali::Toolkit::Visual::Base result;
91684
91685   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91686   arg2 = (Dali::Property::Map *)jarg2;
91687   if (!arg2) {
91688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91689     return 0;
91690   }
91691   {
91692     try {
91693       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91694     } catch (std::out_of_range& e) {
91695       {
91696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91697       };
91698     } catch (std::exception& e) {
91699       {
91700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91701       };
91702     } catch (Dali::DaliException e) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91705       };
91706     } catch (...) {
91707       {
91708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91709       };
91710     }
91711   }
91712
91713   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91714   return jresult;
91715 }
91716
91717
91718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91719   void * jresult ;
91720   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91721   Dali::Image *arg2 = 0 ;
91722   Dali::Toolkit::Visual::Base result;
91723
91724   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91725   arg2 = (Dali::Image *)jarg2;
91726   if (!arg2) {
91727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91728     return 0;
91729   }
91730   {
91731     try {
91732       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91733     } catch (std::out_of_range& e) {
91734       {
91735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91736       };
91737     } catch (std::exception& e) {
91738       {
91739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91740       };
91741     } catch (Dali::DaliException e) {
91742       {
91743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91744       };
91745     } catch (...) {
91746       {
91747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91748       };
91749     }
91750   }
91751
91752   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91753   return jresult;
91754 }
91755
91756
91757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91758   void * jresult ;
91759   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91760   std::string *arg2 = 0 ;
91761   Dali::ImageDimensions arg3 ;
91762   Dali::ImageDimensions *argp3 ;
91763   Dali::Toolkit::Visual::Base result;
91764
91765   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91766   if (!jarg2) {
91767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91768     return 0;
91769   }
91770   std::string arg2_str(jarg2);
91771   arg2 = &arg2_str;
91772   argp3 = (Dali::ImageDimensions *)jarg3;
91773   if (!argp3) {
91774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91775     return 0;
91776   }
91777   arg3 = *argp3;
91778   {
91779     try {
91780       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91781     } catch (std::out_of_range& e) {
91782       {
91783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91784       };
91785     } catch (std::exception& e) {
91786       {
91787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91788       };
91789     } catch (Dali::DaliException e) {
91790       {
91791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91792       };
91793     } catch (...) {
91794       {
91795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91796       };
91797     }
91798   }
91799
91800   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91801
91802   //argout typemap for const std::string&
91803
91804   return jresult;
91805 }
91806
91807
91808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91809   void * jresult ;
91810   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91811
91812   {
91813     try {
91814       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91815     } catch (std::out_of_range& e) {
91816       {
91817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91818       };
91819     } catch (std::exception& e) {
91820       {
91821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91822       };
91823     } catch (Dali::DaliException e) {
91824       {
91825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91826       };
91827     } catch (...) {
91828       {
91829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91830       };
91831     }
91832   }
91833
91834   jresult = (void *)result;
91835   return jresult;
91836 }
91837
91838
91839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91840   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91841
91842   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91843   {
91844     try {
91845       delete arg1;
91846     } catch (std::out_of_range& e) {
91847       {
91848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91849       };
91850     } catch (std::exception& e) {
91851       {
91852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91853       };
91854     } catch (Dali::DaliException e) {
91855       {
91856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91857       };
91858     } catch (...) {
91859       {
91860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91861       };
91862     }
91863   }
91864
91865 }
91866
91867
91868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91869   void * jresult ;
91870   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91871   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91872
91873   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91874   if (!arg1) {
91875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91876     return 0;
91877   }
91878   {
91879     try {
91880       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91881     } catch (std::out_of_range& e) {
91882       {
91883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91884       };
91885     } catch (std::exception& e) {
91886       {
91887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91888       };
91889     } catch (Dali::DaliException e) {
91890       {
91891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91892       };
91893     } catch (...) {
91894       {
91895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91896       };
91897     }
91898   }
91899
91900   jresult = (void *)result;
91901   return jresult;
91902 }
91903
91904
91905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91906   void * jresult ;
91907   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91908   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91909   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91910
91911   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91912   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91913   if (!arg2) {
91914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91915     return 0;
91916   }
91917   {
91918     try {
91919       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91920     } catch (std::out_of_range& e) {
91921       {
91922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91923       };
91924     } catch (std::exception& e) {
91925       {
91926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91927       };
91928     } catch (Dali::DaliException e) {
91929       {
91930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91931       };
91932     } catch (...) {
91933       {
91934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91935       };
91936     }
91937   }
91938
91939   jresult = (void *)result;
91940   return jresult;
91941 }
91942
91943
91944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91945   void * jresult ;
91946   Dali::Toolkit::AsyncImageLoader result;
91947
91948   {
91949     try {
91950       result = Dali::Toolkit::AsyncImageLoader::New();
91951     } catch (std::out_of_range& e) {
91952       {
91953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91954       };
91955     } catch (std::exception& e) {
91956       {
91957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91958       };
91959     } catch (Dali::DaliException e) {
91960       {
91961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91962       };
91963     } catch (...) {
91964       {
91965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91966       };
91967     }
91968   }
91969
91970   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91971   return jresult;
91972 }
91973
91974
91975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91976   void * jresult ;
91977   Dali::BaseHandle arg1 ;
91978   Dali::BaseHandle *argp1 ;
91979   Dali::Toolkit::AsyncImageLoader result;
91980
91981   argp1 = (Dali::BaseHandle *)jarg1;
91982   if (!argp1) {
91983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91984     return 0;
91985   }
91986   arg1 = *argp1;
91987   {
91988     try {
91989       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91990     } catch (std::out_of_range& e) {
91991       {
91992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91993       };
91994     } catch (std::exception& e) {
91995       {
91996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91997       };
91998     } catch (Dali::DaliException e) {
91999       {
92000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92001       };
92002     } catch (...) {
92003       {
92004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92005       };
92006     }
92007   }
92008
92009   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92010   return jresult;
92011 }
92012
92013
92014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92015   unsigned int jresult ;
92016   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92017   std::string *arg2 = 0 ;
92018   uint32_t result;
92019
92020   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92021   if (!jarg2) {
92022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92023     return 0;
92024   }
92025   std::string arg2_str(jarg2);
92026   arg2 = &arg2_str;
92027   {
92028     try {
92029       result = (arg1)->Load((std::string const &)*arg2);
92030     } catch (std::out_of_range& e) {
92031       {
92032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92033       };
92034     } catch (std::exception& e) {
92035       {
92036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92037       };
92038     } catch (Dali::DaliException e) {
92039       {
92040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92041       };
92042     } catch (...) {
92043       {
92044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92045       };
92046     }
92047   }
92048
92049   jresult = result;
92050
92051   //argout typemap for const std::string&
92052
92053   return jresult;
92054 }
92055
92056
92057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92058   unsigned int jresult ;
92059   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92060   std::string *arg2 = 0 ;
92061   Dali::ImageDimensions arg3 ;
92062   Dali::ImageDimensions *argp3 ;
92063   uint32_t result;
92064
92065   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92066   if (!jarg2) {
92067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92068     return 0;
92069   }
92070   std::string arg2_str(jarg2);
92071   arg2 = &arg2_str;
92072   argp3 = (Dali::ImageDimensions *)jarg3;
92073   if (!argp3) {
92074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92075     return 0;
92076   }
92077   arg3 = *argp3;
92078   {
92079     try {
92080       result = (arg1)->Load((std::string const &)*arg2,arg3);
92081     } catch (std::out_of_range& e) {
92082       {
92083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92084       };
92085     } catch (std::exception& e) {
92086       {
92087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92088       };
92089     } catch (Dali::DaliException e) {
92090       {
92091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92092       };
92093     } catch (...) {
92094       {
92095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92096       };
92097     }
92098   }
92099
92100   jresult = result;
92101
92102   //argout typemap for const std::string&
92103
92104   return jresult;
92105 }
92106
92107
92108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92109   unsigned int jresult ;
92110   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92111   std::string *arg2 = 0 ;
92112   Dali::ImageDimensions arg3 ;
92113   Dali::FittingMode::Type arg4 ;
92114   Dali::SamplingMode::Type arg5 ;
92115   bool arg6 ;
92116   Dali::ImageDimensions *argp3 ;
92117   uint32_t result;
92118
92119   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92120   if (!jarg2) {
92121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92122     return 0;
92123   }
92124   std::string arg2_str(jarg2);
92125   arg2 = &arg2_str;
92126   argp3 = (Dali::ImageDimensions *)jarg3;
92127   if (!argp3) {
92128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92129     return 0;
92130   }
92131   arg3 = *argp3;
92132   arg4 = (Dali::FittingMode::Type)jarg4;
92133   arg5 = (Dali::SamplingMode::Type)jarg5;
92134   arg6 = jarg6 ? true : false;
92135   {
92136     try {
92137       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92138     } catch (std::out_of_range& e) {
92139       {
92140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92141       };
92142     } catch (std::exception& e) {
92143       {
92144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92145       };
92146     } catch (Dali::DaliException e) {
92147       {
92148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92149       };
92150     } catch (...) {
92151       {
92152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92153       };
92154     }
92155   }
92156
92157   jresult = result;
92158
92159   //argout typemap for const std::string&
92160
92161   return jresult;
92162 }
92163
92164
92165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92166   unsigned int jresult ;
92167   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92168   uint32_t arg2 ;
92169   bool result;
92170
92171   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92172   arg2 = (uint32_t)jarg2;
92173   {
92174     try {
92175       result = (bool)(arg1)->Cancel(arg2);
92176     } catch (std::out_of_range& e) {
92177       {
92178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92179       };
92180     } catch (std::exception& e) {
92181       {
92182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92183       };
92184     } catch (Dali::DaliException e) {
92185       {
92186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92187       };
92188     } catch (...) {
92189       {
92190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92191       };
92192     }
92193   }
92194
92195   jresult = result;
92196   return jresult;
92197 }
92198
92199
92200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92201   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92202
92203   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92204   {
92205     try {
92206       (arg1)->CancelAll();
92207     } catch (std::out_of_range& e) {
92208       {
92209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92210       };
92211     } catch (std::exception& e) {
92212       {
92213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92214       };
92215     } catch (Dali::DaliException e) {
92216       {
92217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92218       };
92219     } catch (...) {
92220       {
92221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92222       };
92223     }
92224   }
92225
92226 }
92227
92228
92229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92230   void * jresult ;
92231   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92232   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92233
92234   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92235   {
92236     try {
92237       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92238     } catch (std::out_of_range& e) {
92239       {
92240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92241       };
92242     } catch (std::exception& e) {
92243       {
92244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92245       };
92246     } catch (Dali::DaliException e) {
92247       {
92248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92249       };
92250     } catch (...) {
92251       {
92252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92253       };
92254     }
92255   }
92256
92257   jresult = (void *)result;
92258   return jresult;
92259 }
92260
92261
92262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92263   void * jresult ;
92264   std::string *arg1 = 0 ;
92265   Dali::PixelData result;
92266
92267   if (!jarg1) {
92268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92269     return 0;
92270   }
92271   std::string arg1_str(jarg1);
92272   arg1 = &arg1_str;
92273   {
92274     try {
92275       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92276     } catch (std::out_of_range& e) {
92277       {
92278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92279       };
92280     } catch (std::exception& e) {
92281       {
92282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92283       };
92284     } catch (Dali::DaliException e) {
92285       {
92286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92287       };
92288     } catch (...) {
92289       {
92290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92291       };
92292     }
92293   }
92294
92295   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92296
92297   //argout typemap for const std::string&
92298
92299   return jresult;
92300 }
92301
92302
92303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92304   void * jresult ;
92305   std::string *arg1 = 0 ;
92306   Dali::ImageDimensions arg2 ;
92307   Dali::ImageDimensions *argp2 ;
92308   Dali::PixelData result;
92309
92310   if (!jarg1) {
92311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92312     return 0;
92313   }
92314   std::string arg1_str(jarg1);
92315   arg1 = &arg1_str;
92316   argp2 = (Dali::ImageDimensions *)jarg2;
92317   if (!argp2) {
92318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92319     return 0;
92320   }
92321   arg2 = *argp2;
92322   {
92323     try {
92324       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92325     } catch (std::out_of_range& e) {
92326       {
92327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92328       };
92329     } catch (std::exception& e) {
92330       {
92331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92332       };
92333     } catch (Dali::DaliException e) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92336       };
92337     } catch (...) {
92338       {
92339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92340       };
92341     }
92342   }
92343
92344   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92345
92346   //argout typemap for const std::string&
92347
92348   return jresult;
92349 }
92350
92351
92352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92353   void * jresult ;
92354   std::string *arg1 = 0 ;
92355   Dali::ImageDimensions arg2 ;
92356   Dali::FittingMode::Type arg3 ;
92357   Dali::SamplingMode::Type arg4 ;
92358   bool arg5 ;
92359   Dali::ImageDimensions *argp2 ;
92360   Dali::PixelData result;
92361
92362   if (!jarg1) {
92363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92364     return 0;
92365   }
92366   std::string arg1_str(jarg1);
92367   arg1 = &arg1_str;
92368   argp2 = (Dali::ImageDimensions *)jarg2;
92369   if (!argp2) {
92370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92371     return 0;
92372   }
92373   arg2 = *argp2;
92374   arg3 = (Dali::FittingMode::Type)jarg3;
92375   arg4 = (Dali::SamplingMode::Type)jarg4;
92376   arg5 = jarg5 ? true : false;
92377   {
92378     try {
92379       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92380     } catch (std::out_of_range& e) {
92381       {
92382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92383       };
92384     } catch (std::exception& e) {
92385       {
92386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92387       };
92388     } catch (Dali::DaliException e) {
92389       {
92390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92391       };
92392     } catch (...) {
92393       {
92394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92395       };
92396     }
92397   }
92398
92399   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92400
92401   //argout typemap for const std::string&
92402
92403   return jresult;
92404 }
92405
92406
92407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92408   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92409
92410   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92411   {
92412     try {
92413       delete arg1;
92414     } catch (std::out_of_range& e) {
92415       {
92416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92417       };
92418     } catch (std::exception& e) {
92419       {
92420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92421       };
92422     } catch (Dali::DaliException e) {
92423       {
92424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92425       };
92426     } catch (...) {
92427       {
92428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92429       };
92430     }
92431   }
92432
92433 }
92434
92435
92436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92437   void * jresult ;
92438   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92439   Dali::Actor arg2 ;
92440   Dali::Actor arg3 ;
92441   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92442   Dali::Actor *argp2 ;
92443   Dali::Actor *argp3 ;
92444   Dali::Actor result;
92445
92446   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92447   argp2 = (Dali::Actor *)jarg2;
92448   if (!argp2) {
92449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92450     return 0;
92451   }
92452   arg2 = *argp2;
92453   argp3 = (Dali::Actor *)jarg3;
92454   if (!argp3) {
92455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92456     return 0;
92457   }
92458   arg3 = *argp3;
92459   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92460   {
92461     try {
92462       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92463     } catch (std::out_of_range& e) {
92464       {
92465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92466       };
92467     } catch (std::exception& e) {
92468       {
92469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92470       };
92471     } catch (Dali::DaliException e) {
92472       {
92473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92474       };
92475     } catch (...) {
92476       {
92477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92478       };
92479     }
92480   }
92481
92482   jresult = new Dali::Actor((const Dali::Actor &)result);
92483   return jresult;
92484 }
92485
92486
92487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92488   void * jresult ;
92489   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92490
92491   {
92492     try {
92493       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92494     } catch (std::out_of_range& e) {
92495       {
92496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92497       };
92498     } catch (std::exception& e) {
92499       {
92500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92501       };
92502     } catch (Dali::DaliException e) {
92503       {
92504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92505       };
92506     } catch (...) {
92507       {
92508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92509       };
92510     }
92511   }
92512
92513   jresult = (void *)result;
92514   return jresult;
92515 }
92516
92517
92518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92519   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92520   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92521   if (director) {
92522     director->swig_connect_director(callback0);
92523   }
92524 }
92525
92526
92527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92528   KeyboardFocusManager arg1 ;
92529   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92530   KeyboardFocusManager *argp1 ;
92531
92532   argp1 = (KeyboardFocusManager *)jarg1;
92533   if (!argp1) {
92534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92535     return ;
92536   }
92537   arg1 = *argp1;
92538   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92539   if (!arg2) {
92540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92541     return ;
92542   }
92543   {
92544     try {
92545       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92546     } catch (std::out_of_range& e) {
92547       {
92548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92549       };
92550     } catch (std::exception& e) {
92551       {
92552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92553       };
92554     } catch (Dali::DaliException e) {
92555       {
92556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92557       };
92558     } catch (...) {
92559       {
92560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92561       };
92562     }
92563   }
92564
92565 }
92566
92567
92568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92569   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92570
92571   arg1 = (std::vector< unsigned int > *)jarg1;
92572   {
92573     try {
92574       (arg1)->clear();
92575     } catch (std::out_of_range& e) {
92576       {
92577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92578       };
92579     } catch (std::exception& e) {
92580       {
92581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92582       };
92583     } catch (Dali::DaliException e) {
92584       {
92585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92586       };
92587     } catch (...) {
92588       {
92589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92590       };
92591     }
92592   }
92593
92594 }
92595
92596
92597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92598   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92599   unsigned int *arg2 = 0 ;
92600   unsigned int temp2 ;
92601
92602   arg1 = (std::vector< unsigned int > *)jarg1;
92603   temp2 = (unsigned int)jarg2;
92604   arg2 = &temp2;
92605   {
92606     try {
92607       (arg1)->push_back((unsigned int const &)*arg2);
92608     } catch (std::out_of_range& e) {
92609       {
92610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92611       };
92612     } catch (std::exception& e) {
92613       {
92614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92615       };
92616     } catch (Dali::DaliException e) {
92617       {
92618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92619       };
92620     } catch (...) {
92621       {
92622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92623       };
92624     }
92625   }
92626
92627 }
92628
92629
92630 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92631   unsigned long jresult ;
92632   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92633   std::vector< unsigned int >::size_type result;
92634
92635   arg1 = (std::vector< unsigned int > *)jarg1;
92636   {
92637     try {
92638       result = ((std::vector< unsigned int > const *)arg1)->size();
92639     } catch (std::out_of_range& e) {
92640       {
92641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92642       };
92643     } catch (std::exception& e) {
92644       {
92645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92646       };
92647     } catch (Dali::DaliException e) {
92648       {
92649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92650       };
92651     } catch (...) {
92652       {
92653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92654       };
92655     }
92656   }
92657
92658   jresult = (unsigned long)result;
92659   return jresult;
92660 }
92661
92662
92663 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92664   unsigned long jresult ;
92665   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92666   std::vector< unsigned int >::size_type result;
92667
92668   arg1 = (std::vector< unsigned int > *)jarg1;
92669   {
92670     try {
92671       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92672     } catch (std::out_of_range& e) {
92673       {
92674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92675       };
92676     } catch (std::exception& e) {
92677       {
92678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92679       };
92680     } catch (Dali::DaliException e) {
92681       {
92682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92683       };
92684     } catch (...) {
92685       {
92686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92687       };
92688     }
92689   }
92690
92691   jresult = (unsigned long)result;
92692   return jresult;
92693 }
92694
92695
92696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92697   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92698   std::vector< unsigned int >::size_type arg2 ;
92699
92700   arg1 = (std::vector< unsigned int > *)jarg1;
92701   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92702   {
92703     try {
92704       (arg1)->reserve(arg2);
92705     } catch (std::out_of_range& e) {
92706       {
92707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92708       };
92709     } catch (std::exception& e) {
92710       {
92711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92712       };
92713     } catch (Dali::DaliException e) {
92714       {
92715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92716       };
92717     } catch (...) {
92718       {
92719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92720       };
92721     }
92722   }
92723
92724 }
92725
92726
92727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92728   void * jresult ;
92729   std::vector< unsigned int > *result = 0 ;
92730
92731   {
92732     try {
92733       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92734     } catch (std::out_of_range& e) {
92735       {
92736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92737       };
92738     } catch (std::exception& e) {
92739       {
92740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92741       };
92742     } catch (Dali::DaliException e) {
92743       {
92744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92745       };
92746     } catch (...) {
92747       {
92748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92749       };
92750     }
92751   }
92752
92753   jresult = (void *)result;
92754   return jresult;
92755 }
92756
92757
92758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92759   void * jresult ;
92760   std::vector< unsigned int > *arg1 = 0 ;
92761   std::vector< unsigned int > *result = 0 ;
92762
92763   arg1 = (std::vector< unsigned int > *)jarg1;
92764   if (!arg1) {
92765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92766     return 0;
92767   }
92768   {
92769     try {
92770       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92771     } catch (std::out_of_range& e) {
92772       {
92773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92774       };
92775     } catch (std::exception& e) {
92776       {
92777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92778       };
92779     } catch (Dali::DaliException e) {
92780       {
92781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92782       };
92783     } catch (...) {
92784       {
92785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92786       };
92787     }
92788   }
92789
92790   jresult = (void *)result;
92791   return jresult;
92792 }
92793
92794
92795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92796   void * jresult ;
92797   int arg1 ;
92798   std::vector< unsigned int > *result = 0 ;
92799
92800   arg1 = (int)jarg1;
92801   {
92802     try {
92803       try {
92804         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92805       }
92806       catch(std::out_of_range &_e) {
92807         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92808         return 0;
92809       }
92810
92811     } catch (std::out_of_range& e) {
92812       {
92813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92814       };
92815     } catch (std::exception& e) {
92816       {
92817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92818       };
92819     } catch (Dali::DaliException e) {
92820       {
92821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92822       };
92823     } catch (...) {
92824       {
92825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92826       };
92827     }
92828   }
92829
92830   jresult = (void *)result;
92831   return jresult;
92832 }
92833
92834
92835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92836   unsigned int jresult ;
92837   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92838   int arg2 ;
92839   unsigned int result;
92840
92841   arg1 = (std::vector< unsigned int > *)jarg1;
92842   arg2 = (int)jarg2;
92843   {
92844     try {
92845       try {
92846         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92847       }
92848       catch(std::out_of_range &_e) {
92849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92850         return 0;
92851       }
92852
92853     } catch (std::out_of_range& e) {
92854       {
92855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92856       };
92857     } catch (std::exception& e) {
92858       {
92859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92860       };
92861     } catch (Dali::DaliException e) {
92862       {
92863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92864       };
92865     } catch (...) {
92866       {
92867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92868       };
92869     }
92870   }
92871
92872   jresult = result;
92873   return jresult;
92874 }
92875
92876
92877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92878   unsigned int jresult ;
92879   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92880   int arg2 ;
92881   unsigned int *result = 0 ;
92882
92883   arg1 = (std::vector< unsigned int > *)jarg1;
92884   arg2 = (int)jarg2;
92885   {
92886     try {
92887       try {
92888         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92889       }
92890       catch(std::out_of_range &_e) {
92891         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92892         return 0;
92893       }
92894
92895     } catch (std::out_of_range& e) {
92896       {
92897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92898       };
92899     } catch (std::exception& e) {
92900       {
92901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92902       };
92903     } catch (Dali::DaliException e) {
92904       {
92905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92906       };
92907     } catch (...) {
92908       {
92909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92910       };
92911     }
92912   }
92913
92914   jresult = *result;
92915   return jresult;
92916 }
92917
92918
92919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92920   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92921   int arg2 ;
92922   unsigned int *arg3 = 0 ;
92923   unsigned int temp3 ;
92924
92925   arg1 = (std::vector< unsigned int > *)jarg1;
92926   arg2 = (int)jarg2;
92927   temp3 = (unsigned int)jarg3;
92928   arg3 = &temp3;
92929   {
92930     try {
92931       try {
92932         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92933       }
92934       catch(std::out_of_range &_e) {
92935         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92936         return ;
92937       }
92938
92939     } catch (std::out_of_range& e) {
92940       {
92941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92942       };
92943     } catch (std::exception& e) {
92944       {
92945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92946       };
92947     } catch (Dali::DaliException e) {
92948       {
92949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92950       };
92951     } catch (...) {
92952       {
92953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92954       };
92955     }
92956   }
92957
92958 }
92959
92960
92961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92962   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92963   std::vector< unsigned int > *arg2 = 0 ;
92964
92965   arg1 = (std::vector< unsigned int > *)jarg1;
92966   arg2 = (std::vector< unsigned int > *)jarg2;
92967   if (!arg2) {
92968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92969     return ;
92970   }
92971   {
92972     try {
92973       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92974     } catch (std::out_of_range& e) {
92975       {
92976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92977       };
92978     } catch (std::exception& e) {
92979       {
92980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92981       };
92982     } catch (Dali::DaliException e) {
92983       {
92984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92985       };
92986     } catch (...) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92989       };
92990     }
92991   }
92992
92993 }
92994
92995
92996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92997   void * jresult ;
92998   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92999   int arg2 ;
93000   int arg3 ;
93001   std::vector< unsigned int > *result = 0 ;
93002
93003   arg1 = (std::vector< unsigned int > *)jarg1;
93004   arg2 = (int)jarg2;
93005   arg3 = (int)jarg3;
93006   {
93007     try {
93008       try {
93009         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93010       }
93011       catch(std::out_of_range &_e) {
93012         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93013         return 0;
93014       }
93015       catch(std::invalid_argument &_e) {
93016         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93017         return 0;
93018       }
93019
93020     } catch (std::out_of_range& e) {
93021       {
93022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93023       };
93024     } catch (std::exception& e) {
93025       {
93026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93027       };
93028     } catch (Dali::DaliException e) {
93029       {
93030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93031       };
93032     } catch (...) {
93033       {
93034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93035       };
93036     }
93037   }
93038
93039   jresult = (void *)result;
93040   return jresult;
93041 }
93042
93043
93044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93045   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93046   int arg2 ;
93047   unsigned int *arg3 = 0 ;
93048   unsigned int temp3 ;
93049
93050   arg1 = (std::vector< unsigned int > *)jarg1;
93051   arg2 = (int)jarg2;
93052   temp3 = (unsigned int)jarg3;
93053   arg3 = &temp3;
93054   {
93055     try {
93056       try {
93057         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93058       }
93059       catch(std::out_of_range &_e) {
93060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93061         return ;
93062       }
93063
93064     } catch (std::out_of_range& e) {
93065       {
93066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93067       };
93068     } catch (std::exception& e) {
93069       {
93070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93071       };
93072     } catch (Dali::DaliException e) {
93073       {
93074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93075       };
93076     } catch (...) {
93077       {
93078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93079       };
93080     }
93081   }
93082
93083 }
93084
93085
93086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93087   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93088   int arg2 ;
93089   std::vector< unsigned int > *arg3 = 0 ;
93090
93091   arg1 = (std::vector< unsigned int > *)jarg1;
93092   arg2 = (int)jarg2;
93093   arg3 = (std::vector< unsigned int > *)jarg3;
93094   if (!arg3) {
93095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93096     return ;
93097   }
93098   {
93099     try {
93100       try {
93101         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93102       }
93103       catch(std::out_of_range &_e) {
93104         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93105         return ;
93106       }
93107
93108     } catch (std::out_of_range& e) {
93109       {
93110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93111       };
93112     } catch (std::exception& e) {
93113       {
93114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93115       };
93116     } catch (Dali::DaliException e) {
93117       {
93118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93119       };
93120     } catch (...) {
93121       {
93122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93123       };
93124     }
93125   }
93126
93127 }
93128
93129
93130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93131   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93132   int arg2 ;
93133
93134   arg1 = (std::vector< unsigned int > *)jarg1;
93135   arg2 = (int)jarg2;
93136   {
93137     try {
93138       try {
93139         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93140       }
93141       catch(std::out_of_range &_e) {
93142         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93143         return ;
93144       }
93145
93146     } catch (std::out_of_range& e) {
93147       {
93148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93149       };
93150     } catch (std::exception& e) {
93151       {
93152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93153       };
93154     } catch (Dali::DaliException e) {
93155       {
93156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93157       };
93158     } catch (...) {
93159       {
93160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93161       };
93162     }
93163   }
93164
93165 }
93166
93167
93168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93169   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93170   int arg2 ;
93171   int arg3 ;
93172
93173   arg1 = (std::vector< unsigned int > *)jarg1;
93174   arg2 = (int)jarg2;
93175   arg3 = (int)jarg3;
93176   {
93177     try {
93178       try {
93179         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93180       }
93181       catch(std::out_of_range &_e) {
93182         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93183         return ;
93184       }
93185       catch(std::invalid_argument &_e) {
93186         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93187         return ;
93188       }
93189
93190     } catch (std::out_of_range& e) {
93191       {
93192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93193       };
93194     } catch (std::exception& e) {
93195       {
93196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93197       };
93198     } catch (Dali::DaliException e) {
93199       {
93200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93201       };
93202     } catch (...) {
93203       {
93204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93205       };
93206     }
93207   }
93208
93209 }
93210
93211
93212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93213   void * jresult ;
93214   unsigned int *arg1 = 0 ;
93215   int arg2 ;
93216   unsigned int temp1 ;
93217   std::vector< unsigned int > *result = 0 ;
93218
93219   temp1 = (unsigned int)jarg1;
93220   arg1 = &temp1;
93221   arg2 = (int)jarg2;
93222   {
93223     try {
93224       try {
93225         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93226       }
93227       catch(std::out_of_range &_e) {
93228         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93229         return 0;
93230       }
93231
93232     } catch (std::out_of_range& e) {
93233       {
93234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93235       };
93236     } catch (std::exception& e) {
93237       {
93238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93239       };
93240     } catch (Dali::DaliException e) {
93241       {
93242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93243       };
93244     } catch (...) {
93245       {
93246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93247       };
93248     }
93249   }
93250
93251   jresult = (void *)result;
93252   return jresult;
93253 }
93254
93255
93256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93257   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93258
93259   arg1 = (std::vector< unsigned int > *)jarg1;
93260   {
93261     try {
93262       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93263     } catch (std::out_of_range& e) {
93264       {
93265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93266       };
93267     } catch (std::exception& e) {
93268       {
93269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93270       };
93271     } catch (Dali::DaliException e) {
93272       {
93273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93274       };
93275     } catch (...) {
93276       {
93277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93278       };
93279     }
93280   }
93281
93282 }
93283
93284
93285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93286   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93287   int arg2 ;
93288   int arg3 ;
93289
93290   arg1 = (std::vector< unsigned int > *)jarg1;
93291   arg2 = (int)jarg2;
93292   arg3 = (int)jarg3;
93293   {
93294     try {
93295       try {
93296         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93297       }
93298       catch(std::out_of_range &_e) {
93299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93300         return ;
93301       }
93302       catch(std::invalid_argument &_e) {
93303         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93304         return ;
93305       }
93306
93307     } catch (std::out_of_range& e) {
93308       {
93309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93310       };
93311     } catch (std::exception& e) {
93312       {
93313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93314       };
93315     } catch (Dali::DaliException e) {
93316       {
93317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93318       };
93319     } catch (...) {
93320       {
93321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93322       };
93323     }
93324   }
93325
93326 }
93327
93328
93329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93330   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93331   int arg2 ;
93332   std::vector< unsigned int > *arg3 = 0 ;
93333
93334   arg1 = (std::vector< unsigned int > *)jarg1;
93335   arg2 = (int)jarg2;
93336   arg3 = (std::vector< unsigned int > *)jarg3;
93337   if (!arg3) {
93338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93339     return ;
93340   }
93341   {
93342     try {
93343       try {
93344         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93345       }
93346       catch(std::out_of_range &_e) {
93347         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93348         return ;
93349       }
93350
93351     } catch (std::out_of_range& e) {
93352       {
93353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93354       };
93355     } catch (std::exception& e) {
93356       {
93357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93358       };
93359     } catch (Dali::DaliException e) {
93360       {
93361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93362       };
93363     } catch (...) {
93364       {
93365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93366       };
93367     }
93368   }
93369
93370 }
93371
93372
93373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93374   unsigned int jresult ;
93375   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93376   unsigned int *arg2 = 0 ;
93377   unsigned int temp2 ;
93378   bool result;
93379
93380   arg1 = (std::vector< unsigned int > *)jarg1;
93381   temp2 = (unsigned int)jarg2;
93382   arg2 = &temp2;
93383   {
93384     try {
93385       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93386     } catch (std::out_of_range& e) {
93387       {
93388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93389       };
93390     } catch (std::exception& e) {
93391       {
93392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93393       };
93394     } catch (Dali::DaliException e) {
93395       {
93396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93397       };
93398     } catch (...) {
93399       {
93400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93401       };
93402     }
93403   }
93404
93405   jresult = result;
93406   return jresult;
93407 }
93408
93409
93410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93411   int jresult ;
93412   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93413   unsigned int *arg2 = 0 ;
93414   unsigned int temp2 ;
93415   int result;
93416
93417   arg1 = (std::vector< unsigned int > *)jarg1;
93418   temp2 = (unsigned int)jarg2;
93419   arg2 = &temp2;
93420   {
93421     try {
93422       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93423     } catch (std::out_of_range& e) {
93424       {
93425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (std::exception& e) {
93428       {
93429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93430       };
93431     } catch (Dali::DaliException e) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93434       };
93435     } catch (...) {
93436       {
93437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93438       };
93439     }
93440   }
93441
93442   jresult = result;
93443   return jresult;
93444 }
93445
93446
93447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93448   int jresult ;
93449   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93450   unsigned int *arg2 = 0 ;
93451   unsigned int temp2 ;
93452   int result;
93453
93454   arg1 = (std::vector< unsigned int > *)jarg1;
93455   temp2 = (unsigned int)jarg2;
93456   arg2 = &temp2;
93457   {
93458     try {
93459       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93460     } catch (std::out_of_range& e) {
93461       {
93462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93463       };
93464     } catch (std::exception& e) {
93465       {
93466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93467       };
93468     } catch (Dali::DaliException e) {
93469       {
93470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93471       };
93472     } catch (...) {
93473       {
93474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93475       };
93476     }
93477   }
93478
93479   jresult = result;
93480   return jresult;
93481 }
93482
93483
93484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93485   unsigned int jresult ;
93486   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93487   unsigned int *arg2 = 0 ;
93488   unsigned int temp2 ;
93489   bool result;
93490
93491   arg1 = (std::vector< unsigned int > *)jarg1;
93492   temp2 = (unsigned int)jarg2;
93493   arg2 = &temp2;
93494   {
93495     try {
93496       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93497     } catch (std::out_of_range& e) {
93498       {
93499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93500       };
93501     } catch (std::exception& e) {
93502       {
93503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93504       };
93505     } catch (Dali::DaliException e) {
93506       {
93507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93508       };
93509     } catch (...) {
93510       {
93511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93512       };
93513     }
93514   }
93515
93516   jresult = result;
93517   return jresult;
93518 }
93519
93520
93521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93522   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93523
93524   arg1 = (std::vector< unsigned int > *)jarg1;
93525   {
93526     try {
93527       delete arg1;
93528     } catch (std::out_of_range& e) {
93529       {
93530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93531       };
93532     } catch (std::exception& e) {
93533       {
93534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93535       };
93536     } catch (Dali::DaliException e) {
93537       {
93538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93539       };
93540     } catch (...) {
93541       {
93542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93543       };
93544     }
93545   }
93546
93547 }
93548
93549
93550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93551   void * jresult ;
93552   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93553
93554   {
93555     try {
93556       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93557     } catch (std::out_of_range& e) {
93558       {
93559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93560       };
93561     } catch (std::exception& e) {
93562       {
93563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93564       };
93565     } catch (Dali::DaliException e) {
93566       {
93567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93568       };
93569     } catch (...) {
93570       {
93571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93572       };
93573     }
93574   }
93575
93576   jresult = (void *)result;
93577   return jresult;
93578 }
93579
93580
93581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93582   void * jresult ;
93583   unsigned int arg1 ;
93584   Dali::Actor arg2 ;
93585   Dali::Actor *argp2 ;
93586   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93587
93588   arg1 = (unsigned int)jarg1;
93589   argp2 = (Dali::Actor *)jarg2;
93590   if (!argp2) {
93591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93592     return 0;
93593   }
93594   arg2 = *argp2;
93595   {
93596     try {
93597       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93598     } catch (std::out_of_range& e) {
93599       {
93600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93601       };
93602     } catch (std::exception& e) {
93603       {
93604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93605       };
93606     } catch (Dali::DaliException e) {
93607       {
93608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93609       };
93610     } catch (...) {
93611       {
93612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93613       };
93614     }
93615   }
93616
93617   jresult = (void *)result;
93618   return jresult;
93619 }
93620
93621
93622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93623   void * jresult ;
93624   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93625   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93626
93627   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93628   if (!arg1) {
93629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93630     return 0;
93631   }
93632   {
93633     try {
93634       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93635     } catch (std::out_of_range& e) {
93636       {
93637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93638       };
93639     } catch (std::exception& e) {
93640       {
93641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93642       };
93643     } catch (Dali::DaliException e) {
93644       {
93645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93646       };
93647     } catch (...) {
93648       {
93649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93650       };
93651     }
93652   }
93653
93654   jresult = (void *)result;
93655   return jresult;
93656 }
93657
93658
93659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93660   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93661   unsigned int arg2 ;
93662
93663   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93664   arg2 = (unsigned int)jarg2;
93665   if (arg1) (arg1)->first = arg2;
93666 }
93667
93668
93669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93670   unsigned int jresult ;
93671   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93672   unsigned int result;
93673
93674   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93675   result = (unsigned int) ((arg1)->first);
93676   jresult = result;
93677   return jresult;
93678 }
93679
93680
93681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93682   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93683   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93684
93685   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93686   arg2 = (Dali::Actor *)jarg2;
93687   if (arg1) (arg1)->second = *arg2;
93688 }
93689
93690
93691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93692   void * jresult ;
93693   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93694   Dali::Actor *result = 0 ;
93695
93696   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93697   result = (Dali::Actor *)& ((arg1)->second);
93698   jresult = (void *)result;
93699   return jresult;
93700 }
93701
93702
93703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93704   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93705
93706   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93707   {
93708     try {
93709       delete arg1;
93710     } catch (std::out_of_range& e) {
93711       {
93712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93713       };
93714     } catch (std::exception& e) {
93715       {
93716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93717       };
93718     } catch (Dali::DaliException e) {
93719       {
93720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93721       };
93722     } catch (...) {
93723       {
93724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93725       };
93726     }
93727   }
93728
93729 }
93730
93731
93732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93733   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93734
93735   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93736   {
93737     try {
93738       (arg1)->clear();
93739     } catch (std::out_of_range& e) {
93740       {
93741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93742       };
93743     } catch (std::exception& e) {
93744       {
93745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93746       };
93747     } catch (Dali::DaliException e) {
93748       {
93749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93750       };
93751     } catch (...) {
93752       {
93753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93754       };
93755     }
93756   }
93757
93758 }
93759
93760
93761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93762   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93763   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93764
93765   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93766   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93767   if (!arg2) {
93768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93769     return ;
93770   }
93771   {
93772     try {
93773       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93774     } catch (std::out_of_range& e) {
93775       {
93776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93777       };
93778     } catch (std::exception& e) {
93779       {
93780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93781       };
93782     } catch (Dali::DaliException e) {
93783       {
93784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93785       };
93786     } catch (...) {
93787       {
93788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93789       };
93790     }
93791   }
93792
93793 }
93794
93795
93796 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93797   unsigned long jresult ;
93798   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93799   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93800
93801   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93802   {
93803     try {
93804       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93805     } catch (std::out_of_range& e) {
93806       {
93807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93808       };
93809     } catch (std::exception& e) {
93810       {
93811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93812       };
93813     } catch (Dali::DaliException e) {
93814       {
93815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93816       };
93817     } catch (...) {
93818       {
93819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93820       };
93821     }
93822   }
93823
93824   jresult = (unsigned long)result;
93825   return jresult;
93826 }
93827
93828
93829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93830   unsigned long jresult ;
93831   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93832   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93833
93834   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93835   {
93836     try {
93837       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93838     } catch (std::out_of_range& e) {
93839       {
93840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93841       };
93842     } catch (std::exception& e) {
93843       {
93844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93845       };
93846     } catch (Dali::DaliException e) {
93847       {
93848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93849       };
93850     } catch (...) {
93851       {
93852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93853       };
93854     }
93855   }
93856
93857   jresult = (unsigned long)result;
93858   return jresult;
93859 }
93860
93861
93862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93863   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93864   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93865
93866   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93867   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93868   {
93869     try {
93870       (arg1)->reserve(arg2);
93871     } catch (std::out_of_range& e) {
93872       {
93873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93874       };
93875     } catch (std::exception& e) {
93876       {
93877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93878       };
93879     } catch (Dali::DaliException e) {
93880       {
93881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93882       };
93883     } catch (...) {
93884       {
93885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93886       };
93887     }
93888   }
93889
93890 }
93891
93892
93893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93894   void * jresult ;
93895   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93896
93897   {
93898     try {
93899       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93900     } catch (std::out_of_range& e) {
93901       {
93902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93903       };
93904     } catch (std::exception& e) {
93905       {
93906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93907       };
93908     } catch (Dali::DaliException e) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93911       };
93912     } catch (...) {
93913       {
93914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93915       };
93916     }
93917   }
93918
93919   jresult = (void *)result;
93920   return jresult;
93921 }
93922
93923
93924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93925   void * jresult ;
93926   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93927   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93928
93929   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93930   if (!arg1) {
93931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93932     return 0;
93933   }
93934   {
93935     try {
93936       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);
93937     } catch (std::out_of_range& e) {
93938       {
93939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93940       };
93941     } catch (std::exception& e) {
93942       {
93943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93944       };
93945     } catch (Dali::DaliException e) {
93946       {
93947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93948       };
93949     } catch (...) {
93950       {
93951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93952       };
93953     }
93954   }
93955
93956   jresult = (void *)result;
93957   return jresult;
93958 }
93959
93960
93961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93962   void * jresult ;
93963   int arg1 ;
93964   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93965
93966   arg1 = (int)jarg1;
93967   {
93968     try {
93969       try {
93970         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);
93971       }
93972       catch(std::out_of_range &_e) {
93973         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93974         return 0;
93975       }
93976
93977     } catch (std::out_of_range& e) {
93978       {
93979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93980       };
93981     } catch (std::exception& e) {
93982       {
93983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93984       };
93985     } catch (Dali::DaliException e) {
93986       {
93987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93988       };
93989     } catch (...) {
93990       {
93991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93992       };
93993     }
93994   }
93995
93996   jresult = (void *)result;
93997   return jresult;
93998 }
93999
94000
94001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94002   void * jresult ;
94003   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94004   int arg2 ;
94005   std::pair< unsigned int,Dali::Actor > result;
94006
94007   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94008   arg2 = (int)jarg2;
94009   {
94010     try {
94011       try {
94012         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94013       }
94014       catch(std::out_of_range &_e) {
94015         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94016         return 0;
94017       }
94018
94019     } catch (std::out_of_range& e) {
94020       {
94021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94022       };
94023     } catch (std::exception& e) {
94024       {
94025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94026       };
94027     } catch (Dali::DaliException e) {
94028       {
94029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94030       };
94031     } catch (...) {
94032       {
94033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94034       };
94035     }
94036   }
94037
94038   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94039   return jresult;
94040 }
94041
94042
94043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94044   void * jresult ;
94045   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94046   int arg2 ;
94047   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94048
94049   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94050   arg2 = (int)jarg2;
94051   {
94052     try {
94053       try {
94054         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94055       }
94056       catch(std::out_of_range &_e) {
94057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94058         return 0;
94059       }
94060
94061     } catch (std::out_of_range& e) {
94062       {
94063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94064       };
94065     } catch (std::exception& e) {
94066       {
94067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94068       };
94069     } catch (Dali::DaliException e) {
94070       {
94071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94072       };
94073     } catch (...) {
94074       {
94075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94076       };
94077     }
94078   }
94079
94080   jresult = (void *)result;
94081   return jresult;
94082 }
94083
94084
94085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94086   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94087   int arg2 ;
94088   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94089
94090   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94091   arg2 = (int)jarg2;
94092   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94093   if (!arg3) {
94094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94095     return ;
94096   }
94097   {
94098     try {
94099       try {
94100         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);
94101       }
94102       catch(std::out_of_range &_e) {
94103         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94104         return ;
94105       }
94106
94107     } catch (std::out_of_range& e) {
94108       {
94109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94110       };
94111     } catch (std::exception& e) {
94112       {
94113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94114       };
94115     } catch (Dali::DaliException e) {
94116       {
94117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94118       };
94119     } catch (...) {
94120       {
94121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94122       };
94123     }
94124   }
94125
94126 }
94127
94128
94129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94130   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94131   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94132
94133   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94134   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94135   if (!arg2) {
94136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94137     return ;
94138   }
94139   {
94140     try {
94141       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);
94142     } catch (std::out_of_range& e) {
94143       {
94144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94145       };
94146     } catch (std::exception& e) {
94147       {
94148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94149       };
94150     } catch (Dali::DaliException e) {
94151       {
94152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94153       };
94154     } catch (...) {
94155       {
94156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94157       };
94158     }
94159   }
94160
94161 }
94162
94163
94164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94165   void * jresult ;
94166   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94167   int arg2 ;
94168   int arg3 ;
94169   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94170
94171   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94172   arg2 = (int)jarg2;
94173   arg3 = (int)jarg3;
94174   {
94175     try {
94176       try {
94177         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);
94178       }
94179       catch(std::out_of_range &_e) {
94180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94181         return 0;
94182       }
94183       catch(std::invalid_argument &_e) {
94184         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94185         return 0;
94186       }
94187
94188     } catch (std::out_of_range& e) {
94189       {
94190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94191       };
94192     } catch (std::exception& e) {
94193       {
94194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94195       };
94196     } catch (Dali::DaliException e) {
94197       {
94198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94199       };
94200     } catch (...) {
94201       {
94202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94203       };
94204     }
94205   }
94206
94207   jresult = (void *)result;
94208   return jresult;
94209 }
94210
94211
94212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94213   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94214   int arg2 ;
94215   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94216
94217   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94218   arg2 = (int)jarg2;
94219   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94220   if (!arg3) {
94221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94222     return ;
94223   }
94224   {
94225     try {
94226       try {
94227         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);
94228       }
94229       catch(std::out_of_range &_e) {
94230         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94231         return ;
94232       }
94233
94234     } catch (std::out_of_range& e) {
94235       {
94236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94237       };
94238     } catch (std::exception& e) {
94239       {
94240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94241       };
94242     } catch (Dali::DaliException e) {
94243       {
94244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94245       };
94246     } catch (...) {
94247       {
94248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94249       };
94250     }
94251   }
94252
94253 }
94254
94255
94256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94257   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94258   int arg2 ;
94259   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94260
94261   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94262   arg2 = (int)jarg2;
94263   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94264   if (!arg3) {
94265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94266     return ;
94267   }
94268   {
94269     try {
94270       try {
94271         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);
94272       }
94273       catch(std::out_of_range &_e) {
94274         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94275         return ;
94276       }
94277
94278     } catch (std::out_of_range& e) {
94279       {
94280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94281       };
94282     } catch (std::exception& e) {
94283       {
94284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94285       };
94286     } catch (Dali::DaliException e) {
94287       {
94288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94289       };
94290     } catch (...) {
94291       {
94292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94293       };
94294     }
94295   }
94296
94297 }
94298
94299
94300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94301   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94302   int arg2 ;
94303
94304   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94305   arg2 = (int)jarg2;
94306   {
94307     try {
94308       try {
94309         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94310       }
94311       catch(std::out_of_range &_e) {
94312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94313         return ;
94314       }
94315
94316     } catch (std::out_of_range& e) {
94317       {
94318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94319       };
94320     } catch (std::exception& e) {
94321       {
94322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94323       };
94324     } catch (Dali::DaliException e) {
94325       {
94326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94327       };
94328     } catch (...) {
94329       {
94330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94331       };
94332     }
94333   }
94334
94335 }
94336
94337
94338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94339   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94340   int arg2 ;
94341   int arg3 ;
94342
94343   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94344   arg2 = (int)jarg2;
94345   arg3 = (int)jarg3;
94346   {
94347     try {
94348       try {
94349         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94350       }
94351       catch(std::out_of_range &_e) {
94352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94353         return ;
94354       }
94355       catch(std::invalid_argument &_e) {
94356         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94357         return ;
94358       }
94359
94360     } catch (std::out_of_range& e) {
94361       {
94362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94363       };
94364     } catch (std::exception& e) {
94365       {
94366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94367       };
94368     } catch (Dali::DaliException e) {
94369       {
94370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94371       };
94372     } catch (...) {
94373       {
94374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94375       };
94376     }
94377   }
94378
94379 }
94380
94381
94382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94383   void * jresult ;
94384   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94385   int arg2 ;
94386   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94387
94388   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94389   if (!arg1) {
94390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94391     return 0;
94392   }
94393   arg2 = (int)jarg2;
94394   {
94395     try {
94396       try {
94397         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);
94398       }
94399       catch(std::out_of_range &_e) {
94400         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94401         return 0;
94402       }
94403
94404     } catch (std::out_of_range& e) {
94405       {
94406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94407       };
94408     } catch (std::exception& e) {
94409       {
94410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94411       };
94412     } catch (Dali::DaliException e) {
94413       {
94414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94415       };
94416     } catch (...) {
94417       {
94418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94419       };
94420     }
94421   }
94422
94423   jresult = (void *)result;
94424   return jresult;
94425 }
94426
94427
94428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94429   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94430
94431   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94432   {
94433     try {
94434       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94435     } catch (std::out_of_range& e) {
94436       {
94437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94438       };
94439     } catch (std::exception& e) {
94440       {
94441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94442       };
94443     } catch (Dali::DaliException e) {
94444       {
94445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94446       };
94447     } catch (...) {
94448       {
94449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94450       };
94451     }
94452   }
94453
94454 }
94455
94456
94457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94458   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94459   int arg2 ;
94460   int arg3 ;
94461
94462   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94463   arg2 = (int)jarg2;
94464   arg3 = (int)jarg3;
94465   {
94466     try {
94467       try {
94468         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94469       }
94470       catch(std::out_of_range &_e) {
94471         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94472         return ;
94473       }
94474       catch(std::invalid_argument &_e) {
94475         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94476         return ;
94477       }
94478
94479     } catch (std::out_of_range& e) {
94480       {
94481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94482       };
94483     } catch (std::exception& e) {
94484       {
94485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94486       };
94487     } catch (Dali::DaliException e) {
94488       {
94489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94490       };
94491     } catch (...) {
94492       {
94493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94494       };
94495     }
94496   }
94497
94498 }
94499
94500
94501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94502   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94503   int arg2 ;
94504   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94505
94506   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94507   arg2 = (int)jarg2;
94508   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94509   if (!arg3) {
94510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94511     return ;
94512   }
94513   {
94514     try {
94515       try {
94516         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);
94517       }
94518       catch(std::out_of_range &_e) {
94519         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94520         return ;
94521       }
94522
94523     } catch (std::out_of_range& e) {
94524       {
94525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94526       };
94527     } catch (std::exception& e) {
94528       {
94529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94530       };
94531     } catch (Dali::DaliException e) {
94532       {
94533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94534       };
94535     } catch (...) {
94536       {
94537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94538       };
94539     }
94540   }
94541
94542 }
94543
94544
94545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94546   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94547
94548   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94549   {
94550     try {
94551       delete arg1;
94552     } catch (std::out_of_range& e) {
94553       {
94554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94555       };
94556     } catch (std::exception& e) {
94557       {
94558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94559       };
94560     } catch (Dali::DaliException e) {
94561       {
94562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94563       };
94564     } catch (...) {
94565       {
94566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94567       };
94568     }
94569   }
94570
94571 }
94572
94573
94574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94575   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94576
94577   arg1 = (std::vector< Dali::Actor > *)jarg1;
94578   {
94579     try {
94580       (arg1)->clear();
94581     } catch (std::out_of_range& e) {
94582       {
94583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94584       };
94585     } catch (std::exception& e) {
94586       {
94587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94588       };
94589     } catch (Dali::DaliException e) {
94590       {
94591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94592       };
94593     } catch (...) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94596       };
94597     }
94598   }
94599
94600 }
94601
94602
94603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94604   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94605   Dali::Actor *arg2 = 0 ;
94606
94607   arg1 = (std::vector< Dali::Actor > *)jarg1;
94608   arg2 = (Dali::Actor *)jarg2;
94609   if (!arg2) {
94610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94611     return ;
94612   }
94613   {
94614     try {
94615       (arg1)->push_back((Dali::Actor const &)*arg2);
94616     } catch (std::out_of_range& e) {
94617       {
94618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94619       };
94620     } catch (std::exception& e) {
94621       {
94622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94623       };
94624     } catch (Dali::DaliException e) {
94625       {
94626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94627       };
94628     } catch (...) {
94629       {
94630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94631       };
94632     }
94633   }
94634
94635 }
94636
94637
94638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94639   unsigned long jresult ;
94640   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94641   std::vector< Dali::Actor >::size_type result;
94642
94643   arg1 = (std::vector< Dali::Actor > *)jarg1;
94644   {
94645     try {
94646       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94647     } catch (std::out_of_range& e) {
94648       {
94649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94650       };
94651     } catch (std::exception& e) {
94652       {
94653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94654       };
94655     } catch (Dali::DaliException e) {
94656       {
94657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94658       };
94659     } catch (...) {
94660       {
94661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94662       };
94663     }
94664   }
94665
94666   jresult = (unsigned long)result;
94667   return jresult;
94668 }
94669
94670
94671 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94672   unsigned long jresult ;
94673   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94674   std::vector< Dali::Actor >::size_type result;
94675
94676   arg1 = (std::vector< Dali::Actor > *)jarg1;
94677   {
94678     try {
94679       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94680     } catch (std::out_of_range& e) {
94681       {
94682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94683       };
94684     } catch (std::exception& e) {
94685       {
94686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94687       };
94688     } catch (Dali::DaliException e) {
94689       {
94690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94691       };
94692     } catch (...) {
94693       {
94694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94695       };
94696     }
94697   }
94698
94699   jresult = (unsigned long)result;
94700   return jresult;
94701 }
94702
94703
94704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94705   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94706   std::vector< Dali::Actor >::size_type arg2 ;
94707
94708   arg1 = (std::vector< Dali::Actor > *)jarg1;
94709   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94710   {
94711     try {
94712       (arg1)->reserve(arg2);
94713     } catch (std::out_of_range& e) {
94714       {
94715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94716       };
94717     } catch (std::exception& e) {
94718       {
94719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94720       };
94721     } catch (Dali::DaliException e) {
94722       {
94723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94724       };
94725     } catch (...) {
94726       {
94727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94728       };
94729     }
94730   }
94731
94732 }
94733
94734
94735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94736   void * jresult ;
94737   std::vector< Dali::Actor > *result = 0 ;
94738
94739   {
94740     try {
94741       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94742     } catch (std::out_of_range& e) {
94743       {
94744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94745       };
94746     } catch (std::exception& e) {
94747       {
94748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94749       };
94750     } catch (Dali::DaliException e) {
94751       {
94752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94753       };
94754     } catch (...) {
94755       {
94756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94757       };
94758     }
94759   }
94760
94761   jresult = (void *)result;
94762   return jresult;
94763 }
94764
94765
94766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94767   void * jresult ;
94768   std::vector< Dali::Actor > *arg1 = 0 ;
94769   std::vector< Dali::Actor > *result = 0 ;
94770
94771   arg1 = (std::vector< Dali::Actor > *)jarg1;
94772   if (!arg1) {
94773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94774     return 0;
94775   }
94776   {
94777     try {
94778       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94779     } catch (std::out_of_range& e) {
94780       {
94781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94782       };
94783     } catch (std::exception& e) {
94784       {
94785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94786       };
94787     } catch (Dali::DaliException e) {
94788       {
94789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94790       };
94791     } catch (...) {
94792       {
94793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94794       };
94795     }
94796   }
94797
94798   jresult = (void *)result;
94799   return jresult;
94800 }
94801
94802
94803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94804   void * jresult ;
94805   int arg1 ;
94806   std::vector< Dali::Actor > *result = 0 ;
94807
94808   arg1 = (int)jarg1;
94809   {
94810     try {
94811       try {
94812         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94813       }
94814       catch(std::out_of_range &_e) {
94815         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94816         return 0;
94817       }
94818
94819     } catch (std::out_of_range& e) {
94820       {
94821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94822       };
94823     } catch (std::exception& e) {
94824       {
94825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94826       };
94827     } catch (Dali::DaliException e) {
94828       {
94829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94830       };
94831     } catch (...) {
94832       {
94833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94834       };
94835     }
94836   }
94837
94838   jresult = (void *)result;
94839   return jresult;
94840 }
94841
94842
94843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94844   void * jresult ;
94845   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94846   int arg2 ;
94847   Dali::Actor result;
94848
94849   arg1 = (std::vector< Dali::Actor > *)jarg1;
94850   arg2 = (int)jarg2;
94851   {
94852     try {
94853       try {
94854         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94855       }
94856       catch(std::out_of_range &_e) {
94857         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94858         return 0;
94859       }
94860
94861     } catch (std::out_of_range& e) {
94862       {
94863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94864       };
94865     } catch (std::exception& e) {
94866       {
94867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94868       };
94869     } catch (Dali::DaliException e) {
94870       {
94871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94872       };
94873     } catch (...) {
94874       {
94875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94876       };
94877     }
94878   }
94879
94880   jresult = new Dali::Actor((const Dali::Actor &)result);
94881   return jresult;
94882 }
94883
94884
94885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94886   void * jresult ;
94887   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94888   int arg2 ;
94889   Dali::Actor *result = 0 ;
94890
94891   arg1 = (std::vector< Dali::Actor > *)jarg1;
94892   arg2 = (int)jarg2;
94893   {
94894     try {
94895       try {
94896         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94897       }
94898       catch(std::out_of_range &_e) {
94899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94900         return 0;
94901       }
94902
94903     } catch (std::out_of_range& e) {
94904       {
94905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94906       };
94907     } catch (std::exception& e) {
94908       {
94909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94910       };
94911     } catch (Dali::DaliException e) {
94912       {
94913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94914       };
94915     } catch (...) {
94916       {
94917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94918       };
94919     }
94920   }
94921
94922   jresult = (void *)result;
94923   return jresult;
94924 }
94925
94926
94927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94928   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94929   int arg2 ;
94930   Dali::Actor *arg3 = 0 ;
94931
94932   arg1 = (std::vector< Dali::Actor > *)jarg1;
94933   arg2 = (int)jarg2;
94934   arg3 = (Dali::Actor *)jarg3;
94935   if (!arg3) {
94936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94937     return ;
94938   }
94939   {
94940     try {
94941       try {
94942         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94943       }
94944       catch(std::out_of_range &_e) {
94945         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94946         return ;
94947       }
94948
94949     } catch (std::out_of_range& e) {
94950       {
94951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94952       };
94953     } catch (std::exception& e) {
94954       {
94955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94956       };
94957     } catch (Dali::DaliException e) {
94958       {
94959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94960       };
94961     } catch (...) {
94962       {
94963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94964       };
94965     }
94966   }
94967
94968 }
94969
94970
94971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94972   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94973   std::vector< Dali::Actor > *arg2 = 0 ;
94974
94975   arg1 = (std::vector< Dali::Actor > *)jarg1;
94976   arg2 = (std::vector< Dali::Actor > *)jarg2;
94977   if (!arg2) {
94978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94979     return ;
94980   }
94981   {
94982     try {
94983       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94984     } catch (std::out_of_range& e) {
94985       {
94986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94987       };
94988     } catch (std::exception& e) {
94989       {
94990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94991       };
94992     } catch (Dali::DaliException e) {
94993       {
94994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94995       };
94996     } catch (...) {
94997       {
94998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94999       };
95000     }
95001   }
95002
95003 }
95004
95005
95006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95007   void * jresult ;
95008   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95009   int arg2 ;
95010   int arg3 ;
95011   std::vector< Dali::Actor > *result = 0 ;
95012
95013   arg1 = (std::vector< Dali::Actor > *)jarg1;
95014   arg2 = (int)jarg2;
95015   arg3 = (int)jarg3;
95016   {
95017     try {
95018       try {
95019         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95020       }
95021       catch(std::out_of_range &_e) {
95022         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95023         return 0;
95024       }
95025       catch(std::invalid_argument &_e) {
95026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95027         return 0;
95028       }
95029
95030     } catch (std::out_of_range& e) {
95031       {
95032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95033       };
95034     } catch (std::exception& e) {
95035       {
95036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95037       };
95038     } catch (Dali::DaliException e) {
95039       {
95040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95041       };
95042     } catch (...) {
95043       {
95044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95045       };
95046     }
95047   }
95048
95049   jresult = (void *)result;
95050   return jresult;
95051 }
95052
95053
95054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95055   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95056   int arg2 ;
95057   Dali::Actor *arg3 = 0 ;
95058
95059   arg1 = (std::vector< Dali::Actor > *)jarg1;
95060   arg2 = (int)jarg2;
95061   arg3 = (Dali::Actor *)jarg3;
95062   if (!arg3) {
95063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95064     return ;
95065   }
95066   {
95067     try {
95068       try {
95069         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95070       }
95071       catch(std::out_of_range &_e) {
95072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95073         return ;
95074       }
95075
95076     } catch (std::out_of_range& e) {
95077       {
95078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95079       };
95080     } catch (std::exception& e) {
95081       {
95082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95083       };
95084     } catch (Dali::DaliException e) {
95085       {
95086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95087       };
95088     } catch (...) {
95089       {
95090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95091       };
95092     }
95093   }
95094
95095 }
95096
95097
95098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95099   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95100   int arg2 ;
95101   std::vector< Dali::Actor > *arg3 = 0 ;
95102
95103   arg1 = (std::vector< Dali::Actor > *)jarg1;
95104   arg2 = (int)jarg2;
95105   arg3 = (std::vector< Dali::Actor > *)jarg3;
95106   if (!arg3) {
95107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95108     return ;
95109   }
95110   {
95111     try {
95112       try {
95113         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95114       }
95115       catch(std::out_of_range &_e) {
95116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95117         return ;
95118       }
95119
95120     } catch (std::out_of_range& e) {
95121       {
95122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95123       };
95124     } catch (std::exception& e) {
95125       {
95126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95127       };
95128     } catch (Dali::DaliException e) {
95129       {
95130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95131       };
95132     } catch (...) {
95133       {
95134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95135       };
95136     }
95137   }
95138
95139 }
95140
95141
95142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95143   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95144   int arg2 ;
95145
95146   arg1 = (std::vector< Dali::Actor > *)jarg1;
95147   arg2 = (int)jarg2;
95148   {
95149     try {
95150       try {
95151         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95152       }
95153       catch(std::out_of_range &_e) {
95154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95155         return ;
95156       }
95157
95158     } catch (std::out_of_range& e) {
95159       {
95160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95161       };
95162     } catch (std::exception& e) {
95163       {
95164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95165       };
95166     } catch (Dali::DaliException e) {
95167       {
95168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95169       };
95170     } catch (...) {
95171       {
95172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95173       };
95174     }
95175   }
95176
95177 }
95178
95179
95180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95181   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95182   int arg2 ;
95183   int arg3 ;
95184
95185   arg1 = (std::vector< Dali::Actor > *)jarg1;
95186   arg2 = (int)jarg2;
95187   arg3 = (int)jarg3;
95188   {
95189     try {
95190       try {
95191         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95192       }
95193       catch(std::out_of_range &_e) {
95194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95195         return ;
95196       }
95197       catch(std::invalid_argument &_e) {
95198         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95199         return ;
95200       }
95201
95202     } catch (std::out_of_range& e) {
95203       {
95204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95205       };
95206     } catch (std::exception& e) {
95207       {
95208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95209       };
95210     } catch (Dali::DaliException e) {
95211       {
95212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95213       };
95214     } catch (...) {
95215       {
95216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95217       };
95218     }
95219   }
95220
95221 }
95222
95223
95224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95225   void * jresult ;
95226   Dali::Actor *arg1 = 0 ;
95227   int arg2 ;
95228   std::vector< Dali::Actor > *result = 0 ;
95229
95230   arg1 = (Dali::Actor *)jarg1;
95231   if (!arg1) {
95232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95233     return 0;
95234   }
95235   arg2 = (int)jarg2;
95236   {
95237     try {
95238       try {
95239         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95240       }
95241       catch(std::out_of_range &_e) {
95242         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95243         return 0;
95244       }
95245
95246     } catch (std::out_of_range& e) {
95247       {
95248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95249       };
95250     } catch (std::exception& e) {
95251       {
95252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95253       };
95254     } catch (Dali::DaliException e) {
95255       {
95256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95257       };
95258     } catch (...) {
95259       {
95260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95261       };
95262     }
95263   }
95264
95265   jresult = (void *)result;
95266   return jresult;
95267 }
95268
95269
95270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95271   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95272
95273   arg1 = (std::vector< Dali::Actor > *)jarg1;
95274   {
95275     try {
95276       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95277     } catch (std::out_of_range& e) {
95278       {
95279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95280       };
95281     } catch (std::exception& e) {
95282       {
95283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95284       };
95285     } catch (Dali::DaliException e) {
95286       {
95287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95288       };
95289     } catch (...) {
95290       {
95291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95292       };
95293     }
95294   }
95295
95296 }
95297
95298
95299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95300   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95301   int arg2 ;
95302   int arg3 ;
95303
95304   arg1 = (std::vector< Dali::Actor > *)jarg1;
95305   arg2 = (int)jarg2;
95306   arg3 = (int)jarg3;
95307   {
95308     try {
95309       try {
95310         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95311       }
95312       catch(std::out_of_range &_e) {
95313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95314         return ;
95315       }
95316       catch(std::invalid_argument &_e) {
95317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95318         return ;
95319       }
95320
95321     } catch (std::out_of_range& e) {
95322       {
95323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95324       };
95325     } catch (std::exception& e) {
95326       {
95327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95328       };
95329     } catch (Dali::DaliException e) {
95330       {
95331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95332       };
95333     } catch (...) {
95334       {
95335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95336       };
95337     }
95338   }
95339
95340 }
95341
95342
95343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95344   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95345   int arg2 ;
95346   std::vector< Dali::Actor > *arg3 = 0 ;
95347
95348   arg1 = (std::vector< Dali::Actor > *)jarg1;
95349   arg2 = (int)jarg2;
95350   arg3 = (std::vector< Dali::Actor > *)jarg3;
95351   if (!arg3) {
95352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95353     return ;
95354   }
95355   {
95356     try {
95357       try {
95358         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95359       }
95360       catch(std::out_of_range &_e) {
95361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95362         return ;
95363       }
95364
95365     } catch (std::out_of_range& e) {
95366       {
95367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95368       };
95369     } catch (std::exception& e) {
95370       {
95371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95372       };
95373     } catch (Dali::DaliException e) {
95374       {
95375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95376       };
95377     } catch (...) {
95378       {
95379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95380       };
95381     }
95382   }
95383
95384 }
95385
95386
95387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95388   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95389
95390   arg1 = (std::vector< Dali::Actor > *)jarg1;
95391   {
95392     try {
95393       delete arg1;
95394     } catch (std::out_of_range& e) {
95395       {
95396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95397       };
95398     } catch (std::exception& e) {
95399       {
95400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95401       };
95402     } catch (Dali::DaliException e) {
95403       {
95404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95405       };
95406     } catch (...) {
95407       {
95408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95409       };
95410     }
95411   }
95412
95413 }
95414
95415
95416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95417   unsigned int jresult ;
95418   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95419   bool result;
95420
95421   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95422   {
95423     try {
95424       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95425     } catch (std::out_of_range& e) {
95426       {
95427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95428       };
95429     } catch (std::exception& e) {
95430       {
95431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95432       };
95433     } catch (Dali::DaliException e) {
95434       {
95435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95436       };
95437     } catch (...) {
95438       {
95439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95440       };
95441     }
95442   }
95443
95444   jresult = result;
95445   return jresult;
95446 }
95447
95448
95449 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95450   unsigned long jresult ;
95451   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95452   std::size_t result;
95453
95454   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95455   {
95456     try {
95457       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95458     } catch (std::out_of_range& e) {
95459       {
95460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95461       };
95462     } catch (std::exception& e) {
95463       {
95464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95465       };
95466     } catch (Dali::DaliException e) {
95467       {
95468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95469       };
95470     } catch (...) {
95471       {
95472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95473       };
95474     }
95475   }
95476
95477   jresult = (unsigned long)result;
95478   return jresult;
95479 }
95480
95481
95482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95483   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95484   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95485
95486   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95487   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95488   {
95489     try {
95490       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95491     } catch (std::out_of_range& e) {
95492       {
95493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95494       };
95495     } catch (std::exception& e) {
95496       {
95497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95498       };
95499     } catch (Dali::DaliException e) {
95500       {
95501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95502       };
95503     } catch (...) {
95504       {
95505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95506       };
95507     }
95508   }
95509
95510 }
95511
95512
95513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95514   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95515   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95516
95517   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95518   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95519   {
95520     try {
95521       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95522     } catch (std::out_of_range& e) {
95523       {
95524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95525       };
95526     } catch (std::exception& e) {
95527       {
95528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95529       };
95530     } catch (Dali::DaliException e) {
95531       {
95532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95533       };
95534     } catch (...) {
95535       {
95536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95537       };
95538     }
95539   }
95540
95541 }
95542
95543
95544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95545   unsigned int jresult ;
95546   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95547   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95548   bool result;
95549
95550   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95551   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95552   if (!arg2) {
95553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95554     return 0;
95555   }
95556   {
95557     try {
95558       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95559     } catch (std::out_of_range& e) {
95560       {
95561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95562       };
95563     } catch (std::exception& e) {
95564       {
95565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95566       };
95567     } catch (Dali::DaliException e) {
95568       {
95569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95570       };
95571     } catch (...) {
95572       {
95573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95574       };
95575     }
95576   }
95577
95578   jresult = result;
95579   return jresult;
95580 }
95581
95582
95583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95584   void * jresult ;
95585   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95586
95587   {
95588     try {
95589       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95590     } catch (std::out_of_range& e) {
95591       {
95592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95593       };
95594     } catch (std::exception& e) {
95595       {
95596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95597       };
95598     } catch (Dali::DaliException e) {
95599       {
95600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95601       };
95602     } catch (...) {
95603       {
95604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95605       };
95606     }
95607   }
95608
95609   jresult = (void *)result;
95610   return jresult;
95611 }
95612
95613
95614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95615   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95616
95617   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95618   {
95619     try {
95620       delete arg1;
95621     } catch (std::out_of_range& e) {
95622       {
95623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95624       };
95625     } catch (std::exception& e) {
95626       {
95627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95628       };
95629     } catch (Dali::DaliException e) {
95630       {
95631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95632       };
95633     } catch (...) {
95634       {
95635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95636       };
95637     }
95638   }
95639
95640 }
95641
95642
95643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95644   unsigned int jresult ;
95645   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95646   bool result;
95647
95648   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95649   {
95650     try {
95651       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);
95652     } catch (std::out_of_range& e) {
95653       {
95654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95655       };
95656     } catch (std::exception& e) {
95657       {
95658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95659       };
95660     } catch (Dali::DaliException e) {
95661       {
95662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95663       };
95664     } catch (...) {
95665       {
95666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95667       };
95668     }
95669   }
95670
95671   jresult = result;
95672   return jresult;
95673 }
95674
95675
95676 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95677   unsigned long jresult ;
95678   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95679   std::size_t result;
95680
95681   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95682   {
95683     try {
95684       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);
95685     } catch (std::out_of_range& e) {
95686       {
95687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95688       };
95689     } catch (std::exception& e) {
95690       {
95691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95692       };
95693     } catch (Dali::DaliException e) {
95694       {
95695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95696       };
95697     } catch (...) {
95698       {
95699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95700       };
95701     }
95702   }
95703
95704   jresult = (unsigned long)result;
95705   return jresult;
95706 }
95707
95708
95709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95710   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95711   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95712
95713   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95714   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95715   {
95716     try {
95717       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95718     } catch (std::out_of_range& e) {
95719       {
95720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95721       };
95722     } catch (std::exception& e) {
95723       {
95724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95725       };
95726     } catch (Dali::DaliException e) {
95727       {
95728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95729       };
95730     } catch (...) {
95731       {
95732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95733       };
95734     }
95735   }
95736
95737 }
95738
95739
95740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95741   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95742   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95743
95744   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95745   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95746   {
95747     try {
95748       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95749     } catch (std::out_of_range& e) {
95750       {
95751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95752       };
95753     } catch (std::exception& e) {
95754       {
95755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95756       };
95757     } catch (Dali::DaliException e) {
95758       {
95759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95760       };
95761     } catch (...) {
95762       {
95763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95764       };
95765     }
95766   }
95767
95768 }
95769
95770
95771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95772   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95773   Dali::Actor arg2 ;
95774   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95775   Dali::Actor *argp2 ;
95776
95777   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95778   argp2 = (Dali::Actor *)jarg2;
95779   if (!argp2) {
95780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95781     return ;
95782   }
95783   arg2 = *argp2;
95784   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95785   {
95786     try {
95787       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95788     } catch (std::out_of_range& e) {
95789       {
95790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95791       };
95792     } catch (std::exception& e) {
95793       {
95794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95795       };
95796     } catch (Dali::DaliException e) {
95797       {
95798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95799       };
95800     } catch (...) {
95801       {
95802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95803       };
95804     }
95805   }
95806
95807 }
95808
95809
95810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95811   void * jresult ;
95812   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95813
95814   {
95815     try {
95816       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95817     } catch (std::out_of_range& e) {
95818       {
95819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95820       };
95821     } catch (std::exception& e) {
95822       {
95823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95824       };
95825     } catch (Dali::DaliException e) {
95826       {
95827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95828       };
95829     } catch (...) {
95830       {
95831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95832       };
95833     }
95834   }
95835
95836   jresult = (void *)result;
95837   return jresult;
95838 }
95839
95840
95841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95842   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95843
95844   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95845   {
95846     try {
95847       delete arg1;
95848     } catch (std::out_of_range& e) {
95849       {
95850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95851       };
95852     } catch (std::exception& e) {
95853       {
95854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95855       };
95856     } catch (Dali::DaliException e) {
95857       {
95858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95859       };
95860     } catch (...) {
95861       {
95862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95863       };
95864     }
95865   }
95866
95867 }
95868
95869
95870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95871   unsigned int jresult ;
95872   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95873   bool result;
95874
95875   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95876   {
95877     try {
95878       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95879     } catch (std::out_of_range& e) {
95880       {
95881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95882       };
95883     } catch (std::exception& e) {
95884       {
95885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95886       };
95887     } catch (Dali::DaliException e) {
95888       {
95889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95890       };
95891     } catch (...) {
95892       {
95893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95894       };
95895     }
95896   }
95897
95898   jresult = result;
95899   return jresult;
95900 }
95901
95902
95903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95904   unsigned long jresult ;
95905   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95906   std::size_t result;
95907
95908   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95909   {
95910     try {
95911       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95912     } catch (std::out_of_range& e) {
95913       {
95914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95915       };
95916     } catch (std::exception& e) {
95917       {
95918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95919       };
95920     } catch (Dali::DaliException e) {
95921       {
95922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95923       };
95924     } catch (...) {
95925       {
95926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95927       };
95928     }
95929   }
95930
95931   jresult = (unsigned long)result;
95932   return jresult;
95933 }
95934
95935
95936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95937   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95938   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95939
95940   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95941   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95942   {
95943     try {
95944       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95945     } catch (std::out_of_range& e) {
95946       {
95947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95948       };
95949     } catch (std::exception& e) {
95950       {
95951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95952       };
95953     } catch (Dali::DaliException e) {
95954       {
95955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95956       };
95957     } catch (...) {
95958       {
95959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95960       };
95961     }
95962   }
95963
95964 }
95965
95966
95967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95968   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95969   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95970
95971   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95972   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95973   {
95974     try {
95975       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95976     } catch (std::out_of_range& e) {
95977       {
95978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95979       };
95980     } catch (std::exception& e) {
95981       {
95982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95983       };
95984     } catch (Dali::DaliException e) {
95985       {
95986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95987       };
95988     } catch (...) {
95989       {
95990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95991       };
95992     }
95993   }
95994
95995 }
95996
95997
95998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95999   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96000   Dali::Actor arg2 ;
96001   Dali::Actor arg3 ;
96002   Dali::Actor *argp2 ;
96003   Dali::Actor *argp3 ;
96004
96005   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96006   argp2 = (Dali::Actor *)jarg2;
96007   if (!argp2) {
96008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96009     return ;
96010   }
96011   arg2 = *argp2;
96012   argp3 = (Dali::Actor *)jarg3;
96013   if (!argp3) {
96014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96015     return ;
96016   }
96017   arg3 = *argp3;
96018   {
96019     try {
96020       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96021     } catch (std::out_of_range& e) {
96022       {
96023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96024       };
96025     } catch (std::exception& e) {
96026       {
96027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96028       };
96029     } catch (Dali::DaliException e) {
96030       {
96031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96032       };
96033     } catch (...) {
96034       {
96035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96036       };
96037     }
96038   }
96039
96040 }
96041
96042
96043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96044   void * jresult ;
96045   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96046
96047   {
96048     try {
96049       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96050     } catch (std::out_of_range& e) {
96051       {
96052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96053       };
96054     } catch (std::exception& e) {
96055       {
96056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96057       };
96058     } catch (Dali::DaliException e) {
96059       {
96060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96061       };
96062     } catch (...) {
96063       {
96064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96065       };
96066     }
96067   }
96068
96069   jresult = (void *)result;
96070   return jresult;
96071 }
96072
96073
96074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96075   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96076
96077   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96078   {
96079     try {
96080       delete arg1;
96081     } catch (std::out_of_range& e) {
96082       {
96083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96084       };
96085     } catch (std::exception& e) {
96086       {
96087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96088       };
96089     } catch (Dali::DaliException e) {
96090       {
96091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96092       };
96093     } catch (...) {
96094       {
96095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96096       };
96097     }
96098   }
96099
96100 }
96101
96102
96103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96104   unsigned int jresult ;
96105   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96106   bool result;
96107
96108   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96109   {
96110     try {
96111       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96112     } catch (std::out_of_range& e) {
96113       {
96114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96115       };
96116     } catch (std::exception& e) {
96117       {
96118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96119       };
96120     } catch (Dali::DaliException e) {
96121       {
96122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96123       };
96124     } catch (...) {
96125       {
96126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96127       };
96128     }
96129   }
96130
96131   jresult = result;
96132   return jresult;
96133 }
96134
96135
96136 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96137   unsigned long jresult ;
96138   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96139   std::size_t result;
96140
96141   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96142   {
96143     try {
96144       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96145     } catch (std::out_of_range& e) {
96146       {
96147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96148       };
96149     } catch (std::exception& e) {
96150       {
96151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96152       };
96153     } catch (Dali::DaliException e) {
96154       {
96155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96156       };
96157     } catch (...) {
96158       {
96159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96160       };
96161     }
96162   }
96163
96164   jresult = (unsigned long)result;
96165   return jresult;
96166 }
96167
96168
96169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96170   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96171   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96172
96173   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96174   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96175   {
96176     try {
96177       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96178     } catch (std::out_of_range& e) {
96179       {
96180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96181       };
96182     } catch (std::exception& e) {
96183       {
96184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96185       };
96186     } catch (Dali::DaliException e) {
96187       {
96188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96189       };
96190     } catch (...) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96193       };
96194     }
96195   }
96196
96197 }
96198
96199
96200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96201   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96202   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96203
96204   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96205   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96206   {
96207     try {
96208       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96209     } catch (std::out_of_range& e) {
96210       {
96211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96212       };
96213     } catch (std::exception& e) {
96214       {
96215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96216       };
96217     } catch (Dali::DaliException e) {
96218       {
96219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96220       };
96221     } catch (...) {
96222       {
96223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96224       };
96225     }
96226   }
96227
96228 }
96229
96230
96231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96232   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96233   Dali::Actor arg2 ;
96234   bool arg3 ;
96235   Dali::Actor *argp2 ;
96236
96237   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96238   argp2 = (Dali::Actor *)jarg2;
96239   if (!argp2) {
96240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96241     return ;
96242   }
96243   arg2 = *argp2;
96244   arg3 = jarg3 ? true : false;
96245   {
96246     try {
96247       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96248     } catch (std::out_of_range& e) {
96249       {
96250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96251       };
96252     } catch (std::exception& e) {
96253       {
96254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96255       };
96256     } catch (Dali::DaliException e) {
96257       {
96258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96259       };
96260     } catch (...) {
96261       {
96262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96263       };
96264     }
96265   }
96266
96267 }
96268
96269
96270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96271   void * jresult ;
96272   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96273
96274   {
96275     try {
96276       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96277     } catch (std::out_of_range& e) {
96278       {
96279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96280       };
96281     } catch (std::exception& e) {
96282       {
96283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96284       };
96285     } catch (Dali::DaliException e) {
96286       {
96287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96288       };
96289     } catch (...) {
96290       {
96291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96292       };
96293     }
96294   }
96295
96296   jresult = (void *)result;
96297   return jresult;
96298 }
96299
96300
96301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96302   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96303
96304   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96305   {
96306     try {
96307       delete arg1;
96308     } catch (std::out_of_range& e) {
96309       {
96310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96311       };
96312     } catch (std::exception& e) {
96313       {
96314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96315       };
96316     } catch (Dali::DaliException e) {
96317       {
96318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96319       };
96320     } catch (...) {
96321       {
96322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96323       };
96324     }
96325   }
96326
96327 }
96328
96329
96330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96331   unsigned int jresult ;
96332   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96333   bool result;
96334
96335   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96336   {
96337     try {
96338       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);
96339     } catch (std::out_of_range& e) {
96340       {
96341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96342       };
96343     } catch (std::exception& e) {
96344       {
96345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96346       };
96347     } catch (Dali::DaliException e) {
96348       {
96349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96350       };
96351     } catch (...) {
96352       {
96353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96354       };
96355     }
96356   }
96357
96358   jresult = result;
96359   return jresult;
96360 }
96361
96362
96363 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96364   unsigned long jresult ;
96365   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96366   std::size_t result;
96367
96368   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96369   {
96370     try {
96371       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);
96372     } catch (std::out_of_range& e) {
96373       {
96374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96375       };
96376     } catch (std::exception& e) {
96377       {
96378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96379       };
96380     } catch (Dali::DaliException e) {
96381       {
96382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96383       };
96384     } catch (...) {
96385       {
96386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96387       };
96388     }
96389   }
96390
96391   jresult = (unsigned long)result;
96392   return jresult;
96393 }
96394
96395
96396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96397   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96398   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96399
96400   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96401   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96402   {
96403     try {
96404       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96405     } catch (std::out_of_range& e) {
96406       {
96407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96408       };
96409     } catch (std::exception& e) {
96410       {
96411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96412       };
96413     } catch (Dali::DaliException e) {
96414       {
96415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96416       };
96417     } catch (...) {
96418       {
96419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96420       };
96421     }
96422   }
96423
96424 }
96425
96426
96427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96428   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96429   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96430
96431   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96432   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96433   {
96434     try {
96435       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96436     } catch (std::out_of_range& e) {
96437       {
96438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96439       };
96440     } catch (std::exception& e) {
96441       {
96442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96443       };
96444     } catch (Dali::DaliException e) {
96445       {
96446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96447       };
96448     } catch (...) {
96449       {
96450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96451       };
96452     }
96453   }
96454
96455 }
96456
96457
96458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96459   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96460   Dali::Toolkit::StyleManager arg2 ;
96461   Dali::StyleChange::Type arg3 ;
96462   Dali::Toolkit::StyleManager *argp2 ;
96463
96464   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96465   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96466   if (!argp2) {
96467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96468     return ;
96469   }
96470   arg2 = *argp2;
96471   arg3 = (Dali::StyleChange::Type)jarg3;
96472   {
96473     try {
96474       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96475     } catch (std::out_of_range& e) {
96476       {
96477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96478       };
96479     } catch (std::exception& e) {
96480       {
96481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96482       };
96483     } catch (Dali::DaliException e) {
96484       {
96485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96486       };
96487     } catch (...) {
96488       {
96489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96490       };
96491     }
96492   }
96493
96494 }
96495
96496
96497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96498   void * jresult ;
96499   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96500
96501   {
96502     try {
96503       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96504     } catch (std::out_of_range& e) {
96505       {
96506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96507       };
96508     } catch (std::exception& e) {
96509       {
96510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96511       };
96512     } catch (Dali::DaliException e) {
96513       {
96514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96515       };
96516     } catch (...) {
96517       {
96518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96519       };
96520     }
96521   }
96522
96523   jresult = (void *)result;
96524   return jresult;
96525 }
96526
96527
96528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96529   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96530
96531   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96532   {
96533     try {
96534       delete arg1;
96535     } catch (std::out_of_range& e) {
96536       {
96537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96538       };
96539     } catch (std::exception& e) {
96540       {
96541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96542       };
96543     } catch (Dali::DaliException e) {
96544       {
96545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96546       };
96547     } catch (...) {
96548       {
96549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96550       };
96551     }
96552   }
96553
96554 }
96555
96556
96557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96558   unsigned int jresult ;
96559   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96560   bool result;
96561
96562   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96563   {
96564     try {
96565       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96566     } catch (std::out_of_range& e) {
96567       {
96568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96569       };
96570     } catch (std::exception& e) {
96571       {
96572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96573       };
96574     } catch (Dali::DaliException e) {
96575       {
96576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96577       };
96578     } catch (...) {
96579       {
96580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96581       };
96582     }
96583   }
96584
96585   jresult = result;
96586   return jresult;
96587 }
96588
96589
96590 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96591   unsigned long jresult ;
96592   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96593   std::size_t result;
96594
96595   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96596   {
96597     try {
96598       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96599     } catch (std::out_of_range& e) {
96600       {
96601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96602       };
96603     } catch (std::exception& e) {
96604       {
96605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96606       };
96607     } catch (Dali::DaliException e) {
96608       {
96609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96610       };
96611     } catch (...) {
96612       {
96613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96614       };
96615     }
96616   }
96617
96618   jresult = (unsigned long)result;
96619   return jresult;
96620 }
96621
96622
96623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96624   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96625   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96626
96627   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96628   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96629   {
96630     try {
96631       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96632     } catch (std::out_of_range& e) {
96633       {
96634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96635       };
96636     } catch (std::exception& e) {
96637       {
96638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96639       };
96640     } catch (Dali::DaliException e) {
96641       {
96642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96643       };
96644     } catch (...) {
96645       {
96646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96647       };
96648     }
96649   }
96650
96651 }
96652
96653
96654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96655   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96656   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96657
96658   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96659   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96660   {
96661     try {
96662       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96663     } catch (std::out_of_range& e) {
96664       {
96665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96666       };
96667     } catch (std::exception& e) {
96668       {
96669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96670       };
96671     } catch (Dali::DaliException e) {
96672       {
96673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96674       };
96675     } catch (...) {
96676       {
96677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96678       };
96679     }
96680   }
96681
96682 }
96683
96684
96685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96686   unsigned int jresult ;
96687   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96688   Dali::Toolkit::Button arg2 ;
96689   Dali::Toolkit::Button *argp2 ;
96690   bool result;
96691
96692   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96693   argp2 = (Dali::Toolkit::Button *)jarg2;
96694   if (!argp2) {
96695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96696     return 0;
96697   }
96698   arg2 = *argp2;
96699   {
96700     try {
96701       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96702     } catch (std::out_of_range& e) {
96703       {
96704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96705       };
96706     } catch (std::exception& e) {
96707       {
96708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96709       };
96710     } catch (Dali::DaliException e) {
96711       {
96712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96713       };
96714     } catch (...) {
96715       {
96716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96717       };
96718     }
96719   }
96720
96721   jresult = result;
96722   return jresult;
96723 }
96724
96725
96726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96727   void * jresult ;
96728   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96729
96730   {
96731     try {
96732       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96733     } catch (std::out_of_range& e) {
96734       {
96735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96736       };
96737     } catch (std::exception& e) {
96738       {
96739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96740       };
96741     } catch (Dali::DaliException e) {
96742       {
96743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96744       };
96745     } catch (...) {
96746       {
96747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96748       };
96749     }
96750   }
96751
96752   jresult = (void *)result;
96753   return jresult;
96754 }
96755
96756
96757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96758   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96759
96760   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96761   {
96762     try {
96763       delete arg1;
96764     } catch (std::out_of_range& e) {
96765       {
96766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96767       };
96768     } catch (std::exception& e) {
96769       {
96770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96771       };
96772     } catch (Dali::DaliException e) {
96773       {
96774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96775       };
96776     } catch (...) {
96777       {
96778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96779       };
96780     }
96781   }
96782
96783 }
96784
96785
96786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96787   unsigned int jresult ;
96788   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96789   bool result;
96790
96791   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96792   {
96793     try {
96794       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96795     } catch (std::out_of_range& e) {
96796       {
96797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96798       };
96799     } catch (std::exception& e) {
96800       {
96801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96802       };
96803     } catch (Dali::DaliException e) {
96804       {
96805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96806       };
96807     } catch (...) {
96808       {
96809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96810       };
96811     }
96812   }
96813
96814   jresult = result;
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96820   unsigned long jresult ;
96821   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96822   std::size_t result;
96823
96824   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96825   {
96826     try {
96827       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96828     } catch (std::out_of_range& e) {
96829       {
96830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96831       };
96832     } catch (std::exception& e) {
96833       {
96834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96835       };
96836     } catch (Dali::DaliException e) {
96837       {
96838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96839       };
96840     } catch (...) {
96841       {
96842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96843       };
96844     }
96845   }
96846
96847   jresult = (unsigned long)result;
96848   return jresult;
96849 }
96850
96851
96852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96853   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96854   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96855
96856   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96857   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96858   {
96859     try {
96860       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96861     } catch (std::out_of_range& e) {
96862       {
96863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96864       };
96865     } catch (std::exception& e) {
96866       {
96867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96868       };
96869     } catch (Dali::DaliException e) {
96870       {
96871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96872       };
96873     } catch (...) {
96874       {
96875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96876       };
96877     }
96878   }
96879
96880 }
96881
96882
96883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96884   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96885   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96886
96887   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96888   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96889   {
96890     try {
96891       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96892     } catch (std::out_of_range& e) {
96893       {
96894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96895       };
96896     } catch (std::exception& e) {
96897       {
96898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96899       };
96900     } catch (Dali::DaliException e) {
96901       {
96902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96903       };
96904     } catch (...) {
96905       {
96906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96907       };
96908     }
96909   }
96910
96911 }
96912
96913
96914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96915   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96916   Dali::Toolkit::GaussianBlurView arg2 ;
96917   Dali::Toolkit::GaussianBlurView *argp2 ;
96918
96919   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96920   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96921   if (!argp2) {
96922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96923     return ;
96924   }
96925   arg2 = *argp2;
96926   {
96927     try {
96928       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96929     } catch (std::out_of_range& e) {
96930       {
96931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96932       };
96933     } catch (std::exception& e) {
96934       {
96935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96936       };
96937     } catch (Dali::DaliException e) {
96938       {
96939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96940       };
96941     } catch (...) {
96942       {
96943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96944       };
96945     }
96946   }
96947
96948 }
96949
96950
96951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96952   void * jresult ;
96953   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96954
96955   {
96956     try {
96957       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96958     } catch (std::out_of_range& e) {
96959       {
96960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96961       };
96962     } catch (std::exception& e) {
96963       {
96964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96965       };
96966     } catch (Dali::DaliException e) {
96967       {
96968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96969       };
96970     } catch (...) {
96971       {
96972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96973       };
96974     }
96975   }
96976
96977   jresult = (void *)result;
96978   return jresult;
96979 }
96980
96981
96982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96983   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96984
96985   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96986   {
96987     try {
96988       delete arg1;
96989     } catch (std::out_of_range& e) {
96990       {
96991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96992       };
96993     } catch (std::exception& e) {
96994       {
96995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96996       };
96997     } catch (Dali::DaliException e) {
96998       {
96999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97000       };
97001     } catch (...) {
97002       {
97003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97004       };
97005     }
97006   }
97007
97008 }
97009
97010
97011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97012   unsigned int jresult ;
97013   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97014   bool result;
97015
97016   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97017   {
97018     try {
97019       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);
97020     } catch (std::out_of_range& e) {
97021       {
97022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97023       };
97024     } catch (std::exception& e) {
97025       {
97026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97027       };
97028     } catch (Dali::DaliException e) {
97029       {
97030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97031       };
97032     } catch (...) {
97033       {
97034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97035       };
97036     }
97037   }
97038
97039   jresult = result;
97040   return jresult;
97041 }
97042
97043
97044 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97045   unsigned long jresult ;
97046   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97047   std::size_t result;
97048
97049   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97050   {
97051     try {
97052       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);
97053     } catch (std::out_of_range& e) {
97054       {
97055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97056       };
97057     } catch (std::exception& e) {
97058       {
97059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97060       };
97061     } catch (Dali::DaliException e) {
97062       {
97063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97064       };
97065     } catch (...) {
97066       {
97067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97068       };
97069     }
97070   }
97071
97072   jresult = (unsigned long)result;
97073   return jresult;
97074 }
97075
97076
97077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97078   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97079   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97080
97081   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97082   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97083   {
97084     try {
97085       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97086     } catch (std::out_of_range& e) {
97087       {
97088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97089       };
97090     } catch (std::exception& e) {
97091       {
97092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97093       };
97094     } catch (Dali::DaliException e) {
97095       {
97096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97097       };
97098     } catch (...) {
97099       {
97100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97101       };
97102     }
97103   }
97104
97105 }
97106
97107
97108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97109   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97110   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97111
97112   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97113   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97114   {
97115     try {
97116       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97117     } catch (std::out_of_range& e) {
97118       {
97119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97120       };
97121     } catch (std::exception& e) {
97122       {
97123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97124       };
97125     } catch (Dali::DaliException e) {
97126       {
97127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97128       };
97129     } catch (...) {
97130       {
97131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97132       };
97133     }
97134   }
97135
97136 }
97137
97138
97139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97140   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97141   Dali::Toolkit::PageTurnView arg2 ;
97142   unsigned int arg3 ;
97143   bool arg4 ;
97144   Dali::Toolkit::PageTurnView *argp2 ;
97145
97146   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97147   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97148   if (!argp2) {
97149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97150     return ;
97151   }
97152   arg2 = *argp2;
97153   arg3 = (unsigned int)jarg3;
97154   arg4 = jarg4 ? true : false;
97155   {
97156     try {
97157       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97158     } catch (std::out_of_range& e) {
97159       {
97160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97161       };
97162     } catch (std::exception& e) {
97163       {
97164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97165       };
97166     } catch (Dali::DaliException e) {
97167       {
97168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97169       };
97170     } catch (...) {
97171       {
97172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97173       };
97174     }
97175   }
97176
97177 }
97178
97179
97180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97181   void * jresult ;
97182   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97183
97184   {
97185     try {
97186       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97187     } catch (std::out_of_range& e) {
97188       {
97189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97190       };
97191     } catch (std::exception& e) {
97192       {
97193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97194       };
97195     } catch (Dali::DaliException e) {
97196       {
97197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97198       };
97199     } catch (...) {
97200       {
97201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97202       };
97203     }
97204   }
97205
97206   jresult = (void *)result;
97207   return jresult;
97208 }
97209
97210
97211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97212   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97213
97214   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97215   {
97216     try {
97217       delete arg1;
97218     } catch (std::out_of_range& e) {
97219       {
97220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97221       };
97222     } catch (std::exception& e) {
97223       {
97224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97225       };
97226     } catch (Dali::DaliException e) {
97227       {
97228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97229       };
97230     } catch (...) {
97231       {
97232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97233       };
97234     }
97235   }
97236
97237 }
97238
97239
97240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97241   unsigned int jresult ;
97242   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97243   bool result;
97244
97245   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97246   {
97247     try {
97248       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97249     } catch (std::out_of_range& e) {
97250       {
97251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97252       };
97253     } catch (std::exception& e) {
97254       {
97255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97256       };
97257     } catch (Dali::DaliException e) {
97258       {
97259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97260       };
97261     } catch (...) {
97262       {
97263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97264       };
97265     }
97266   }
97267
97268   jresult = result;
97269   return jresult;
97270 }
97271
97272
97273 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97274   unsigned long jresult ;
97275   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97276   std::size_t result;
97277
97278   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97279   {
97280     try {
97281       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97282     } catch (std::out_of_range& e) {
97283       {
97284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97285       };
97286     } catch (std::exception& e) {
97287       {
97288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97289       };
97290     } catch (Dali::DaliException e) {
97291       {
97292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97293       };
97294     } catch (...) {
97295       {
97296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97297       };
97298     }
97299   }
97300
97301   jresult = (unsigned long)result;
97302   return jresult;
97303 }
97304
97305
97306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97307   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97308   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97309
97310   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97311   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97312   {
97313     try {
97314       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97315     } catch (std::out_of_range& e) {
97316       {
97317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97318       };
97319     } catch (std::exception& e) {
97320       {
97321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97322       };
97323     } catch (Dali::DaliException e) {
97324       {
97325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97326       };
97327     } catch (...) {
97328       {
97329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97330       };
97331     }
97332   }
97333
97334 }
97335
97336
97337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97338   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97339   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97340
97341   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97342   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97343   {
97344     try {
97345       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97346     } catch (std::out_of_range& e) {
97347       {
97348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97349       };
97350     } catch (std::exception& e) {
97351       {
97352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97353       };
97354     } catch (Dali::DaliException e) {
97355       {
97356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97357       };
97358     } catch (...) {
97359       {
97360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97361       };
97362     }
97363   }
97364
97365 }
97366
97367
97368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97369   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97370   Dali::Toolkit::PageTurnView arg2 ;
97371   Dali::Toolkit::PageTurnView *argp2 ;
97372
97373   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97374   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97375   if (!argp2) {
97376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97377     return ;
97378   }
97379   arg2 = *argp2;
97380   {
97381     try {
97382       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97383     } catch (std::out_of_range& e) {
97384       {
97385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97386       };
97387     } catch (std::exception& e) {
97388       {
97389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97390       };
97391     } catch (Dali::DaliException e) {
97392       {
97393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97394       };
97395     } catch (...) {
97396       {
97397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97398       };
97399     }
97400   }
97401
97402 }
97403
97404
97405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97406   void * jresult ;
97407   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97408
97409   {
97410     try {
97411       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97412     } catch (std::out_of_range& e) {
97413       {
97414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97415       };
97416     } catch (std::exception& e) {
97417       {
97418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97419       };
97420     } catch (Dali::DaliException e) {
97421       {
97422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97423       };
97424     } catch (...) {
97425       {
97426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97427       };
97428     }
97429   }
97430
97431   jresult = (void *)result;
97432   return jresult;
97433 }
97434
97435
97436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97437   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97438
97439   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97440   {
97441     try {
97442       delete arg1;
97443     } catch (std::out_of_range& e) {
97444       {
97445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97446       };
97447     } catch (std::exception& e) {
97448       {
97449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97450       };
97451     } catch (Dali::DaliException e) {
97452       {
97453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97454       };
97455     } catch (...) {
97456       {
97457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97458       };
97459     }
97460   }
97461
97462 }
97463
97464
97465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97466   unsigned int jresult ;
97467   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97468   bool result;
97469
97470   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97471   {
97472     try {
97473       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);
97474     } catch (std::out_of_range& e) {
97475       {
97476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97477       };
97478     } catch (std::exception& e) {
97479       {
97480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97481       };
97482     } catch (Dali::DaliException e) {
97483       {
97484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97485       };
97486     } catch (...) {
97487       {
97488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97489       };
97490     }
97491   }
97492
97493   jresult = result;
97494   return jresult;
97495 }
97496
97497
97498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97499   unsigned long jresult ;
97500   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97501   std::size_t result;
97502
97503   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97504   {
97505     try {
97506       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);
97507     } catch (std::out_of_range& e) {
97508       {
97509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97510       };
97511     } catch (std::exception& e) {
97512       {
97513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97514       };
97515     } catch (Dali::DaliException e) {
97516       {
97517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97518       };
97519     } catch (...) {
97520       {
97521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97522       };
97523     }
97524   }
97525
97526   jresult = (unsigned long)result;
97527   return jresult;
97528 }
97529
97530
97531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97532   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97533   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97534
97535   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97536   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97537   {
97538     try {
97539       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97540     } catch (std::out_of_range& e) {
97541       {
97542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97543       };
97544     } catch (std::exception& e) {
97545       {
97546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97547       };
97548     } catch (Dali::DaliException e) {
97549       {
97550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97551       };
97552     } catch (...) {
97553       {
97554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97555       };
97556     }
97557   }
97558
97559 }
97560
97561
97562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97563   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97564   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97565
97566   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97567   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97568   {
97569     try {
97570       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97571     } catch (std::out_of_range& e) {
97572       {
97573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97574       };
97575     } catch (std::exception& e) {
97576       {
97577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97578       };
97579     } catch (Dali::DaliException e) {
97580       {
97581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97582       };
97583     } catch (...) {
97584       {
97585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97586       };
97587     }
97588   }
97589
97590 }
97591
97592
97593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97594   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97595   Dali::Toolkit::ProgressBar arg2 ;
97596   float arg3 ;
97597   float arg4 ;
97598   Dali::Toolkit::ProgressBar *argp2 ;
97599
97600   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97601   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97602   if (!argp2) {
97603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97604     return ;
97605   }
97606   arg2 = *argp2;
97607   arg3 = (float)jarg3;
97608   arg4 = (float)jarg4;
97609   {
97610     try {
97611       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97612     } catch (std::out_of_range& e) {
97613       {
97614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97615       };
97616     } catch (std::exception& e) {
97617       {
97618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97619       };
97620     } catch (Dali::DaliException e) {
97621       {
97622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97623       };
97624     } catch (...) {
97625       {
97626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97627       };
97628     }
97629   }
97630
97631 }
97632
97633
97634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97635   void * jresult ;
97636   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97637
97638   {
97639     try {
97640       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97641     } catch (std::out_of_range& e) {
97642       {
97643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97644       };
97645     } catch (std::exception& e) {
97646       {
97647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97648       };
97649     } catch (Dali::DaliException e) {
97650       {
97651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97652       };
97653     } catch (...) {
97654       {
97655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97656       };
97657     }
97658   }
97659
97660   jresult = (void *)result;
97661   return jresult;
97662 }
97663
97664
97665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97666   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97667
97668   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97669   {
97670     try {
97671       delete arg1;
97672     } catch (std::out_of_range& e) {
97673       {
97674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97675       };
97676     } catch (std::exception& e) {
97677       {
97678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97679       };
97680     } catch (Dali::DaliException e) {
97681       {
97682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97683       };
97684     } catch (...) {
97685       {
97686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97687       };
97688     }
97689   }
97690
97691 }
97692
97693
97694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97695   unsigned int jresult ;
97696   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97697   bool result;
97698
97699   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97700   {
97701     try {
97702       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);
97703     } catch (std::out_of_range& e) {
97704       {
97705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97706       };
97707     } catch (std::exception& e) {
97708       {
97709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97710       };
97711     } catch (Dali::DaliException e) {
97712       {
97713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97714       };
97715     } catch (...) {
97716       {
97717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97718       };
97719     }
97720   }
97721
97722   jresult = result;
97723   return jresult;
97724 }
97725
97726
97727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97728   unsigned long jresult ;
97729   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97730   std::size_t result;
97731
97732   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97733   {
97734     try {
97735       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);
97736     } catch (std::out_of_range& e) {
97737       {
97738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97739       };
97740     } catch (std::exception& e) {
97741       {
97742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97743       };
97744     } catch (Dali::DaliException e) {
97745       {
97746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97747       };
97748     } catch (...) {
97749       {
97750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97751       };
97752     }
97753   }
97754
97755   jresult = (unsigned long)result;
97756   return jresult;
97757 }
97758
97759
97760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97761   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97762   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97763
97764   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97765   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97766   {
97767     try {
97768       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97769     } catch (std::out_of_range& e) {
97770       {
97771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97772       };
97773     } catch (std::exception& e) {
97774       {
97775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97776       };
97777     } catch (Dali::DaliException e) {
97778       {
97779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97780       };
97781     } catch (...) {
97782       {
97783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97784       };
97785     }
97786   }
97787
97788 }
97789
97790
97791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97792   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97793   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97794
97795   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97796   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97797   {
97798     try {
97799       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97800     } catch (std::out_of_range& e) {
97801       {
97802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97803       };
97804     } catch (std::exception& e) {
97805       {
97806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97807       };
97808     } catch (Dali::DaliException e) {
97809       {
97810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97811       };
97812     } catch (...) {
97813       {
97814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97815       };
97816     }
97817   }
97818
97819 }
97820
97821
97822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97823   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97824   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97825
97826   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97827   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97828   if (!arg2) {
97829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97830     return ;
97831   }
97832   {
97833     try {
97834       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97835     } catch (std::out_of_range& e) {
97836       {
97837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97838       };
97839     } catch (std::exception& e) {
97840       {
97841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97842       };
97843     } catch (Dali::DaliException e) {
97844       {
97845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97846       };
97847     } catch (...) {
97848       {
97849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97850       };
97851     }
97852   }
97853
97854 }
97855
97856
97857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97858   void * jresult ;
97859   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97860
97861   {
97862     try {
97863       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97864     } catch (std::out_of_range& e) {
97865       {
97866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97867       };
97868     } catch (std::exception& e) {
97869       {
97870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97871       };
97872     } catch (Dali::DaliException e) {
97873       {
97874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97875       };
97876     } catch (...) {
97877       {
97878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97879       };
97880     }
97881   }
97882
97883   jresult = (void *)result;
97884   return jresult;
97885 }
97886
97887
97888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97889   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97890
97891   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97892   {
97893     try {
97894       delete arg1;
97895     } catch (std::out_of_range& e) {
97896       {
97897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97898       };
97899     } catch (std::exception& e) {
97900       {
97901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97902       };
97903     } catch (Dali::DaliException e) {
97904       {
97905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97906       };
97907     } catch (...) {
97908       {
97909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97910       };
97911     }
97912   }
97913
97914 }
97915
97916
97917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97918   unsigned int jresult ;
97919   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97920   bool result;
97921
97922   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97923   {
97924     try {
97925       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97926     } catch (std::out_of_range& e) {
97927       {
97928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97929       };
97930     } catch (std::exception& e) {
97931       {
97932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97933       };
97934     } catch (Dali::DaliException e) {
97935       {
97936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97937       };
97938     } catch (...) {
97939       {
97940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97941       };
97942     }
97943   }
97944
97945   jresult = result;
97946   return jresult;
97947 }
97948
97949
97950 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97951   unsigned long jresult ;
97952   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97953   std::size_t result;
97954
97955   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97956   {
97957     try {
97958       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97959     } catch (std::out_of_range& e) {
97960       {
97961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97962       };
97963     } catch (std::exception& e) {
97964       {
97965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97966       };
97967     } catch (Dali::DaliException e) {
97968       {
97969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97970       };
97971     } catch (...) {
97972       {
97973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97974       };
97975     }
97976   }
97977
97978   jresult = (unsigned long)result;
97979   return jresult;
97980 }
97981
97982
97983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97984   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97985   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97986
97987   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97988   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97989   {
97990     try {
97991       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97992     } catch (std::out_of_range& e) {
97993       {
97994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97995       };
97996     } catch (std::exception& e) {
97997       {
97998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97999       };
98000     } catch (Dali::DaliException e) {
98001       {
98002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98003       };
98004     } catch (...) {
98005       {
98006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98007       };
98008     }
98009   }
98010
98011 }
98012
98013
98014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98015   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98016   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98017
98018   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98019   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98020   {
98021     try {
98022       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98023     } catch (std::out_of_range& e) {
98024       {
98025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98026       };
98027     } catch (std::exception& e) {
98028       {
98029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98030       };
98031     } catch (Dali::DaliException e) {
98032       {
98033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98034       };
98035     } catch (...) {
98036       {
98037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98038       };
98039     }
98040   }
98041
98042 }
98043
98044
98045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98046   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98047   Dali::Vector2 *arg2 = 0 ;
98048
98049   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98050   arg2 = (Dali::Vector2 *)jarg2;
98051   if (!arg2) {
98052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98053     return ;
98054   }
98055   {
98056     try {
98057       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98058     } catch (std::out_of_range& e) {
98059       {
98060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98061       };
98062     } catch (std::exception& e) {
98063       {
98064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98065       };
98066     } catch (Dali::DaliException e) {
98067       {
98068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98069       };
98070     } catch (...) {
98071       {
98072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98073       };
98074     }
98075   }
98076
98077 }
98078
98079
98080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98081   void * jresult ;
98082   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98083
98084   {
98085     try {
98086       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98087     } catch (std::out_of_range& e) {
98088       {
98089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98090       };
98091     } catch (std::exception& e) {
98092       {
98093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98094       };
98095     } catch (Dali::DaliException e) {
98096       {
98097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98098       };
98099     } catch (...) {
98100       {
98101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98102       };
98103     }
98104   }
98105
98106   jresult = (void *)result;
98107   return jresult;
98108 }
98109
98110
98111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98112   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98113
98114   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98115   {
98116     try {
98117       delete arg1;
98118     } catch (std::out_of_range& e) {
98119       {
98120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98121       };
98122     } catch (std::exception& e) {
98123       {
98124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98125       };
98126     } catch (Dali::DaliException e) {
98127       {
98128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98129       };
98130     } catch (...) {
98131       {
98132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98133       };
98134     }
98135   }
98136
98137 }
98138
98139
98140
98141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98142   unsigned int jresult ;
98143   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98144   bool result;
98145
98146   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98147   {
98148     try {
98149       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);
98150     } catch (std::out_of_range& e) {
98151       {
98152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98153       };
98154     } catch (std::exception& e) {
98155       {
98156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98157       };
98158     } catch (Dali::DaliException e) {
98159       {
98160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98161       };
98162     } catch (...) {
98163       {
98164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98165       };
98166     }
98167   }
98168
98169   jresult = result;
98170   return jresult;
98171 }
98172
98173
98174 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98175   unsigned long jresult ;
98176   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98177   std::size_t result;
98178
98179   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98180   {
98181     try {
98182       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);
98183     } catch (std::out_of_range& e) {
98184       {
98185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98186       };
98187     } catch (std::exception& e) {
98188       {
98189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98190       };
98191     } catch (Dali::DaliException e) {
98192       {
98193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98194       };
98195     } catch (...) {
98196       {
98197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98198       };
98199     }
98200   }
98201
98202   jresult = (unsigned long)result;
98203   return jresult;
98204 }
98205
98206
98207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98208   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98209   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98210
98211   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98212   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98213   {
98214     try {
98215       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98216     } catch (std::out_of_range& e) {
98217       {
98218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98219       };
98220     } catch (std::exception& e) {
98221       {
98222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98223       };
98224     } catch (Dali::DaliException e) {
98225       {
98226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98227       };
98228     } catch (...) {
98229       {
98230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98231       };
98232     }
98233   }
98234
98235 }
98236
98237
98238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98239   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98240   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98241
98242   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98243   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98244   {
98245     try {
98246       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98247     } catch (std::out_of_range& e) {
98248       {
98249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98250       };
98251     } catch (std::exception& e) {
98252       {
98253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98254       };
98255     } catch (Dali::DaliException e) {
98256       {
98257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98258       };
98259     } catch (...) {
98260       {
98261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98262       };
98263     }
98264   }
98265
98266 }
98267
98268
98269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98270   unsigned int jresult ;
98271   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98272   Dali::Toolkit::Control arg2 ;
98273   Dali::KeyEvent *arg3 = 0 ;
98274   Dali::Toolkit::Control *argp2 ;
98275   bool result;
98276
98277   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98278   argp2 = (Dali::Toolkit::Control *)jarg2;
98279   if (!argp2) {
98280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98281     return 0;
98282   }
98283   arg2 = *argp2;
98284   arg3 = (Dali::KeyEvent *)jarg3;
98285   if (!arg3) {
98286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98287     return 0;
98288   }
98289   {
98290     try {
98291       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);
98292     } catch (std::out_of_range& e) {
98293       {
98294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98295       };
98296     } catch (std::exception& e) {
98297       {
98298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98299       };
98300     } catch (Dali::DaliException e) {
98301       {
98302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98303       };
98304     } catch (...) {
98305       {
98306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98307       };
98308     }
98309   }
98310
98311   jresult = result;
98312   return jresult;
98313 }
98314
98315
98316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98317   void * jresult ;
98318   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98319
98320   {
98321     try {
98322       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98323     } catch (std::out_of_range& e) {
98324       {
98325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98326       };
98327     } catch (std::exception& e) {
98328       {
98329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98330       };
98331     } catch (Dali::DaliException e) {
98332       {
98333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98334       };
98335     } catch (...) {
98336       {
98337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98338       };
98339     }
98340   }
98341
98342   jresult = (void *)result;
98343   return jresult;
98344 }
98345
98346
98347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98348   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98349
98350   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98351   {
98352     try {
98353       delete arg1;
98354     } catch (std::out_of_range& e) {
98355       {
98356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98357       };
98358     } catch (std::exception& e) {
98359       {
98360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98361       };
98362     } catch (Dali::DaliException e) {
98363       {
98364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98365       };
98366     } catch (...) {
98367       {
98368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98369       };
98370     }
98371   }
98372
98373 }
98374
98375
98376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98377   unsigned int jresult ;
98378   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98379   bool result;
98380
98381   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98382   {
98383     try {
98384       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98385     } catch (std::out_of_range& e) {
98386       {
98387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98388       };
98389     } catch (std::exception& e) {
98390       {
98391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98392       };
98393     } catch (Dali::DaliException e) {
98394       {
98395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98396       };
98397     } catch (...) {
98398       {
98399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98400       };
98401     }
98402   }
98403
98404   jresult = result;
98405   return jresult;
98406 }
98407
98408
98409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98410   unsigned long jresult ;
98411   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98412   std::size_t result;
98413
98414   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98415   {
98416     try {
98417       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98418     } catch (std::out_of_range& e) {
98419       {
98420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98421       };
98422     } catch (std::exception& e) {
98423       {
98424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98425       };
98426     } catch (Dali::DaliException e) {
98427       {
98428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98429       };
98430     } catch (...) {
98431       {
98432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98433       };
98434     }
98435   }
98436
98437   jresult = (unsigned long)result;
98438   return jresult;
98439 }
98440
98441
98442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98443   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98444   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98445
98446   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98447   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98448   {
98449     try {
98450       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98451     } catch (std::out_of_range& e) {
98452       {
98453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98454       };
98455     } catch (std::exception& e) {
98456       {
98457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98458       };
98459     } catch (Dali::DaliException e) {
98460       {
98461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98462       };
98463     } catch (...) {
98464       {
98465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98466       };
98467     }
98468   }
98469
98470 }
98471
98472
98473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98474   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98475   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98476
98477   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98478   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98479   {
98480     try {
98481       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98482     } catch (std::out_of_range& e) {
98483       {
98484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98485       };
98486     } catch (std::exception& e) {
98487       {
98488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98489       };
98490     } catch (Dali::DaliException e) {
98491       {
98492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98493       };
98494     } catch (...) {
98495       {
98496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98497       };
98498     }
98499   }
98500
98501 }
98502
98503
98504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98505   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98506   Dali::Toolkit::Control arg2 ;
98507   Dali::Toolkit::Control *argp2 ;
98508
98509   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98510   argp2 = (Dali::Toolkit::Control *)jarg2;
98511   if (!argp2) {
98512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98513     return ;
98514   }
98515   arg2 = *argp2;
98516   {
98517     try {
98518       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98519     } catch (std::out_of_range& e) {
98520       {
98521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98522       };
98523     } catch (std::exception& e) {
98524       {
98525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98526       };
98527     } catch (Dali::DaliException e) {
98528       {
98529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98530       };
98531     } catch (...) {
98532       {
98533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98534       };
98535     }
98536   }
98537
98538 }
98539
98540
98541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98542   void * jresult ;
98543   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98544
98545   {
98546     try {
98547       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98548     } catch (std::out_of_range& e) {
98549       {
98550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98551       };
98552     } catch (std::exception& e) {
98553       {
98554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98555       };
98556     } catch (Dali::DaliException e) {
98557       {
98558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98559       };
98560     } catch (...) {
98561       {
98562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98563       };
98564     }
98565   }
98566
98567   jresult = (void *)result;
98568   return jresult;
98569 }
98570
98571
98572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98573   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98574
98575   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98576   {
98577     try {
98578       delete arg1;
98579     } catch (std::out_of_range& e) {
98580       {
98581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98582       };
98583     } catch (std::exception& e) {
98584       {
98585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98586       };
98587     } catch (Dali::DaliException e) {
98588       {
98589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98590       };
98591     } catch (...) {
98592       {
98593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98594       };
98595     }
98596   }
98597
98598 }
98599
98600
98601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98602   unsigned int jresult ;
98603   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98604   bool result;
98605
98606   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98607   {
98608     try {
98609       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98610     } catch (std::out_of_range& e) {
98611       {
98612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98613       };
98614     } catch (std::exception& e) {
98615       {
98616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98617       };
98618     } catch (Dali::DaliException e) {
98619       {
98620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98621       };
98622     } catch (...) {
98623       {
98624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98625       };
98626     }
98627   }
98628
98629   jresult = result;
98630   return jresult;
98631 }
98632
98633
98634 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98635   unsigned long jresult ;
98636   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98637   std::size_t result;
98638
98639   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98640   {
98641     try {
98642       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98643     } catch (std::out_of_range& e) {
98644       {
98645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98646       };
98647     } catch (std::exception& e) {
98648       {
98649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98650       };
98651     } catch (Dali::DaliException e) {
98652       {
98653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98654       };
98655     } catch (...) {
98656       {
98657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98658       };
98659     }
98660   }
98661
98662   jresult = (unsigned long)result;
98663   return jresult;
98664 }
98665
98666
98667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98668   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98669   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98670
98671   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98672   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98673   {
98674     try {
98675       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98676     } catch (std::out_of_range& e) {
98677       {
98678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98679       };
98680     } catch (std::exception& e) {
98681       {
98682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98683       };
98684     } catch (Dali::DaliException e) {
98685       {
98686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98687       };
98688     } catch (...) {
98689       {
98690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98691       };
98692     }
98693   }
98694
98695 }
98696
98697
98698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98699   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98700   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98701
98702   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98703   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98704   {
98705     try {
98706       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98707     } catch (std::out_of_range& e) {
98708       {
98709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98710       };
98711     } catch (std::exception& e) {
98712       {
98713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98714       };
98715     } catch (Dali::DaliException e) {
98716       {
98717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98718       };
98719     } catch (...) {
98720       {
98721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98722       };
98723     }
98724   }
98725
98726 }
98727
98728
98729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98730   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98731   Dali::Toolkit::VideoView *arg2 = 0 ;
98732
98733   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98734   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98735   if (!arg2) {
98736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98737     return ;
98738   }
98739   {
98740     try {
98741       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98742     } catch (std::out_of_range& e) {
98743       {
98744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98745       };
98746     } catch (std::exception& e) {
98747       {
98748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98749       };
98750     } catch (Dali::DaliException e) {
98751       {
98752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98753       };
98754     } catch (...) {
98755       {
98756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98757       };
98758     }
98759   }
98760
98761 }
98762
98763
98764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98765   void * jresult ;
98766   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98767
98768   {
98769     try {
98770       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98771     } catch (std::out_of_range& e) {
98772       {
98773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98774       };
98775     } catch (std::exception& e) {
98776       {
98777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98778       };
98779     } catch (Dali::DaliException e) {
98780       {
98781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98782       };
98783     } catch (...) {
98784       {
98785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98786       };
98787     }
98788   }
98789
98790   jresult = (void *)result;
98791   return jresult;
98792 }
98793
98794
98795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98796   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98797
98798   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98799   {
98800     try {
98801       delete arg1;
98802     } catch (std::out_of_range& e) {
98803       {
98804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98805       };
98806     } catch (std::exception& e) {
98807       {
98808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98809       };
98810     } catch (Dali::DaliException e) {
98811       {
98812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98813       };
98814     } catch (...) {
98815       {
98816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98817       };
98818     }
98819   }
98820
98821 }
98822
98823
98824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98825   unsigned int jresult ;
98826   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98827   bool result;
98828
98829   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98830   {
98831     try {
98832       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98833     } catch (std::out_of_range& e) {
98834       {
98835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98836       };
98837     } catch (std::exception& e) {
98838       {
98839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98840       };
98841     } catch (Dali::DaliException e) {
98842       {
98843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98844       };
98845     } catch (...) {
98846       {
98847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98848       };
98849     }
98850   }
98851
98852   jresult = result;
98853   return jresult;
98854 }
98855
98856
98857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98858   unsigned long jresult ;
98859   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98860   std::size_t result;
98861
98862   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98863   {
98864     try {
98865       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98866     } catch (std::out_of_range& e) {
98867       {
98868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98869       };
98870     } catch (std::exception& e) {
98871       {
98872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98873       };
98874     } catch (Dali::DaliException e) {
98875       {
98876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98877       };
98878     } catch (...) {
98879       {
98880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98881       };
98882     }
98883   }
98884
98885   jresult = (unsigned long)result;
98886   return jresult;
98887 }
98888
98889
98890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98891   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98892   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98893
98894   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98895   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98896   {
98897     try {
98898       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98899     } catch (std::out_of_range& e) {
98900       {
98901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98902       };
98903     } catch (std::exception& e) {
98904       {
98905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98906       };
98907     } catch (Dali::DaliException e) {
98908       {
98909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98910       };
98911     } catch (...) {
98912       {
98913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98914       };
98915     }
98916   }
98917
98918 }
98919
98920
98921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98922   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98923   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98924
98925   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98926   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98927   {
98928     try {
98929       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98930     } catch (std::out_of_range& e) {
98931       {
98932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98933       };
98934     } catch (std::exception& e) {
98935       {
98936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98937       };
98938     } catch (Dali::DaliException e) {
98939       {
98940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98941       };
98942     } catch (...) {
98943       {
98944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98945       };
98946     }
98947   }
98948
98949 }
98950
98951
98952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98953   unsigned int jresult ;
98954   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98955   Dali::Toolkit::Slider arg2 ;
98956   float arg3 ;
98957   Dali::Toolkit::Slider *argp2 ;
98958   bool result;
98959
98960   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98961   argp2 = (Dali::Toolkit::Slider *)jarg2;
98962   if (!argp2) {
98963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98964     return 0;
98965   }
98966   arg2 = *argp2;
98967   arg3 = (float)jarg3;
98968   {
98969     try {
98970       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98971     } catch (std::out_of_range& e) {
98972       {
98973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98974       };
98975     } catch (std::exception& e) {
98976       {
98977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98978       };
98979     } catch (Dali::DaliException e) {
98980       {
98981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98982       };
98983     } catch (...) {
98984       {
98985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98986       };
98987     }
98988   }
98989
98990   jresult = result;
98991   return jresult;
98992 }
98993
98994
98995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98996   void * jresult ;
98997   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98998
98999   {
99000     try {
99001       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99002     } catch (std::out_of_range& e) {
99003       {
99004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99005       };
99006     } catch (std::exception& e) {
99007       {
99008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99009       };
99010     } catch (Dali::DaliException e) {
99011       {
99012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99013       };
99014     } catch (...) {
99015       {
99016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99017       };
99018     }
99019   }
99020
99021   jresult = (void *)result;
99022   return jresult;
99023 }
99024
99025
99026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99027   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99028
99029   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99030   {
99031     try {
99032       delete arg1;
99033     } catch (std::out_of_range& e) {
99034       {
99035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99036       };
99037     } catch (std::exception& e) {
99038       {
99039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99040       };
99041     } catch (Dali::DaliException e) {
99042       {
99043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99044       };
99045     } catch (...) {
99046       {
99047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99048       };
99049     }
99050   }
99051
99052 }
99053
99054
99055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99056   unsigned int jresult ;
99057   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99058   bool result;
99059
99060   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99061   {
99062     try {
99063       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99064     } catch (std::out_of_range& e) {
99065       {
99066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99067       };
99068     } catch (std::exception& e) {
99069       {
99070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99071       };
99072     } catch (Dali::DaliException e) {
99073       {
99074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99075       };
99076     } catch (...) {
99077       {
99078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99079       };
99080     }
99081   }
99082
99083   jresult = result;
99084   return jresult;
99085 }
99086
99087
99088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99089   unsigned long jresult ;
99090   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99091   std::size_t result;
99092
99093   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99094   {
99095     try {
99096       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99097     } catch (std::out_of_range& e) {
99098       {
99099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99100       };
99101     } catch (std::exception& e) {
99102       {
99103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99104       };
99105     } catch (Dali::DaliException e) {
99106       {
99107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99108       };
99109     } catch (...) {
99110       {
99111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99112       };
99113     }
99114   }
99115
99116   jresult = (unsigned long)result;
99117   return jresult;
99118 }
99119
99120
99121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99122   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99123   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99124
99125   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99126   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99127   {
99128     try {
99129       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99130     } catch (std::out_of_range& e) {
99131       {
99132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99133       };
99134     } catch (std::exception& e) {
99135       {
99136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99137       };
99138     } catch (Dali::DaliException e) {
99139       {
99140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99141       };
99142     } catch (...) {
99143       {
99144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99145       };
99146     }
99147   }
99148
99149 }
99150
99151
99152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99153   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99154   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99155
99156   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99157   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99158   {
99159     try {
99160       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99161     } catch (std::out_of_range& e) {
99162       {
99163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99164       };
99165     } catch (std::exception& e) {
99166       {
99167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99168       };
99169     } catch (Dali::DaliException e) {
99170       {
99171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99172       };
99173     } catch (...) {
99174       {
99175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99176       };
99177     }
99178   }
99179
99180 }
99181
99182
99183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99184   unsigned int jresult ;
99185   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99186   Dali::Toolkit::Slider arg2 ;
99187   int arg3 ;
99188   Dali::Toolkit::Slider *argp2 ;
99189   bool result;
99190
99191   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99192   argp2 = (Dali::Toolkit::Slider *)jarg2;
99193   if (!argp2) {
99194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99195     return 0;
99196   }
99197   arg2 = *argp2;
99198   arg3 = (int)jarg3;
99199   {
99200     try {
99201       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99202     } catch (std::out_of_range& e) {
99203       {
99204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99205       };
99206     } catch (std::exception& e) {
99207       {
99208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99209       };
99210     } catch (Dali::DaliException e) {
99211       {
99212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99213       };
99214     } catch (...) {
99215       {
99216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99217       };
99218     }
99219   }
99220
99221   jresult = result;
99222   return jresult;
99223 }
99224
99225
99226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99227   void * jresult ;
99228   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99229
99230   {
99231     try {
99232       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99233     } catch (std::out_of_range& e) {
99234       {
99235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99236       };
99237     } catch (std::exception& e) {
99238       {
99239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99240       };
99241     } catch (Dali::DaliException e) {
99242       {
99243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99244       };
99245     } catch (...) {
99246       {
99247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99248       };
99249     }
99250   }
99251
99252   jresult = (void *)result;
99253   return jresult;
99254 }
99255
99256
99257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99258   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99259
99260   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99261   {
99262     try {
99263       delete arg1;
99264     } catch (std::out_of_range& e) {
99265       {
99266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99267       };
99268     } catch (std::exception& e) {
99269       {
99270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99271       };
99272     } catch (Dali::DaliException e) {
99273       {
99274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99275       };
99276     } catch (...) {
99277       {
99278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99279       };
99280     }
99281   }
99282
99283 }
99284
99285
99286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99287   void * jresult ;
99288   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99289
99290   {
99291     try {
99292       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99293     } catch (std::out_of_range& e) {
99294       {
99295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99296       };
99297     } catch (std::exception& e) {
99298       {
99299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99300       };
99301     } catch (Dali::DaliException e) {
99302       {
99303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99304       };
99305     } catch (...) {
99306       {
99307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99308       };
99309     }
99310   }
99311
99312   jresult = (void *)result;
99313   return jresult;
99314 }
99315
99316
99317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99318   void * jresult ;
99319   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99320   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99321
99322   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99323   {
99324     try {
99325       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99326     } catch (std::out_of_range& e) {
99327       {
99328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99329       };
99330     } catch (std::exception& e) {
99331       {
99332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99333       };
99334     } catch (Dali::DaliException e) {
99335       {
99336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99337       };
99338     } catch (...) {
99339       {
99340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99341       };
99342     }
99343   }
99344
99345   jresult = (void *)result;
99346   return jresult;
99347 }
99348
99349
99350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99351   void * jresult ;
99352   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99353   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99354
99355   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99356   if (!arg1) {
99357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99358     return 0;
99359   }
99360   {
99361     try {
99362       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99363     } catch (std::out_of_range& e) {
99364       {
99365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99366       };
99367     } catch (std::exception& e) {
99368       {
99369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99370       };
99371     } catch (Dali::DaliException e) {
99372       {
99373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99374       };
99375     } catch (...) {
99376       {
99377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99378       };
99379     }
99380   }
99381
99382   jresult = (void *)result;
99383   return jresult;
99384 }
99385
99386
99387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99388   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99389
99390   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99391   {
99392     try {
99393       delete arg1;
99394     } catch (std::out_of_range& e) {
99395       {
99396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99397       };
99398     } catch (std::exception& e) {
99399       {
99400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99401       };
99402     } catch (Dali::DaliException e) {
99403       {
99404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99405       };
99406     } catch (...) {
99407       {
99408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99409       };
99410     }
99411   }
99412
99413 }
99414
99415
99416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99417   void * jresult ;
99418   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99419   Dali::Toolkit::Ruler *result = 0 ;
99420
99421   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99422   {
99423     try {
99424       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99425     } catch (std::out_of_range& e) {
99426       {
99427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99428       };
99429     } catch (std::exception& e) {
99430       {
99431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99432       };
99433     } catch (Dali::DaliException e) {
99434       {
99435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99436       };
99437     } catch (...) {
99438       {
99439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99440       };
99441     }
99442   }
99443
99444   jresult = (void *)result;
99445   return jresult;
99446 }
99447
99448
99449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99450   void * jresult ;
99451   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99452   Dali::Toolkit::Ruler *result = 0 ;
99453
99454   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99455   {
99456     try {
99457       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99458     } catch (std::out_of_range& e) {
99459       {
99460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99461       };
99462     } catch (std::exception& e) {
99463       {
99464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99465       };
99466     } catch (Dali::DaliException e) {
99467       {
99468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99469       };
99470     } catch (...) {
99471       {
99472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99473       };
99474     }
99475   }
99476
99477   jresult = (void *)result;
99478   return jresult;
99479 }
99480
99481
99482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99483   void * jresult ;
99484   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99485   Dali::Toolkit::Ruler *result = 0 ;
99486
99487   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99488   {
99489     try {
99490       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99491     } catch (std::out_of_range& e) {
99492       {
99493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99494       };
99495     } catch (std::exception& e) {
99496       {
99497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99498       };
99499     } catch (Dali::DaliException e) {
99500       {
99501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99502       };
99503     } catch (...) {
99504       {
99505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99506       };
99507     }
99508   }
99509
99510   jresult = (void *)result;
99511   return jresult;
99512 }
99513
99514
99515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99516   void * jresult ;
99517   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99518   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99519   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99520
99521   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99522   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99523   if (!arg2) {
99524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99525     return 0;
99526   }
99527   {
99528     try {
99529       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99530     } catch (std::out_of_range& e) {
99531       {
99532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99533       };
99534     } catch (std::exception& e) {
99535       {
99536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99537       };
99538     } catch (Dali::DaliException e) {
99539       {
99540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99541       };
99542     } catch (...) {
99543       {
99544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99545       };
99546     }
99547   }
99548
99549   jresult = (void *)result;
99550   return jresult;
99551 }
99552
99553
99554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99555   void * jresult ;
99556   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99557   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99558   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99559
99560   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99561   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99562   {
99563     try {
99564       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99565     } catch (std::out_of_range& e) {
99566       {
99567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99568       };
99569     } catch (std::exception& e) {
99570       {
99571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99572       };
99573     } catch (Dali::DaliException e) {
99574       {
99575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99576       };
99577     } catch (...) {
99578       {
99579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99580       };
99581     }
99582   }
99583
99584   jresult = (void *)result;
99585   return jresult;
99586 }
99587
99588
99589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99591
99592   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99593   {
99594     try {
99595       (arg1)->Reset();
99596     } catch (std::out_of_range& e) {
99597       {
99598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99599       };
99600     } catch (std::exception& e) {
99601       {
99602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99603       };
99604     } catch (Dali::DaliException e) {
99605       {
99606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99607       };
99608     } catch (...) {
99609       {
99610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99611       };
99612     }
99613   }
99614
99615 }
99616
99617
99618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99619   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99620   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99621
99622   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99623   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99624   {
99625     try {
99626       (arg1)->Reset(arg2);
99627     } catch (std::out_of_range& e) {
99628       {
99629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99630       };
99631     } catch (std::exception& e) {
99632       {
99633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99634       };
99635     } catch (Dali::DaliException e) {
99636       {
99637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99638       };
99639     } catch (...) {
99640       {
99641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99642       };
99643     }
99644   }
99645
99646 }
99647
99648
99649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99650   void * jresult ;
99651   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99652   Dali::Toolkit::Ruler *result = 0 ;
99653
99654   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99655   {
99656     try {
99657       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99658     } catch (std::out_of_range& e) {
99659       {
99660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99661       };
99662     } catch (std::exception& e) {
99663       {
99664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99665       };
99666     } catch (Dali::DaliException e) {
99667       {
99668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99669       };
99670     } catch (...) {
99671       {
99672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99673       };
99674     }
99675   }
99676
99677   jresult = (void *)result;
99678   return jresult;
99679 }
99680
99681
99682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99683   float jresult ;
99684   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99685   float arg2 ;
99686   float arg3 ;
99687   float result;
99688
99689   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99690   arg2 = (float)jarg2;
99691   arg3 = (float)jarg3;
99692   {
99693     try {
99694       result = (float)(*arg1)->Snap(arg2,arg3);
99695     } catch (std::out_of_range& e) {
99696       {
99697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99698       };
99699     } catch (std::exception& e) {
99700       {
99701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99702       };
99703     } catch (Dali::DaliException e) {
99704       {
99705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99706       };
99707     } catch (...) {
99708       {
99709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99710       };
99711     }
99712   }
99713
99714   jresult = result;
99715   return jresult;
99716 }
99717
99718
99719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99720   float jresult ;
99721   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99722   float arg2 ;
99723   float result;
99724
99725   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99726   arg2 = (float)jarg2;
99727   {
99728     try {
99729       result = (float)(*arg1)->Snap(arg2);
99730     } catch (std::out_of_range& e) {
99731       {
99732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99733       };
99734     } catch (std::exception& e) {
99735       {
99736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99737       };
99738     } catch (Dali::DaliException e) {
99739       {
99740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99741       };
99742     } catch (...) {
99743       {
99744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99745       };
99746     }
99747   }
99748
99749   jresult = result;
99750   return jresult;
99751 }
99752
99753
99754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99755   float jresult ;
99756   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99757   unsigned int arg2 ;
99758   unsigned int *arg3 = 0 ;
99759   bool arg4 ;
99760   float result;
99761
99762   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99763   arg2 = (unsigned int)jarg2;
99764   arg3 = (unsigned int *)jarg3;
99765   arg4 = jarg4 ? true : false;
99766   {
99767     try {
99768       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99769     } catch (std::out_of_range& e) {
99770       {
99771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99772       };
99773     } catch (std::exception& e) {
99774       {
99775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99776       };
99777     } catch (Dali::DaliException e) {
99778       {
99779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99780       };
99781     } catch (...) {
99782       {
99783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99784       };
99785     }
99786   }
99787
99788   jresult = result;
99789   return jresult;
99790 }
99791
99792
99793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99794   unsigned int jresult ;
99795   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99796   float arg2 ;
99797   bool arg3 ;
99798   unsigned int result;
99799
99800   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99801   arg2 = (float)jarg2;
99802   arg3 = jarg3 ? true : false;
99803   {
99804     try {
99805       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99806     } catch (std::out_of_range& e) {
99807       {
99808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99809       };
99810     } catch (std::exception& e) {
99811       {
99812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99813       };
99814     } catch (Dali::DaliException e) {
99815       {
99816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99817       };
99818     } catch (...) {
99819       {
99820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99821       };
99822     }
99823   }
99824
99825   jresult = result;
99826   return jresult;
99827 }
99828
99829
99830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99831   unsigned int jresult ;
99832   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99833   unsigned int result;
99834
99835   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99836   {
99837     try {
99838       result = (unsigned int)(*arg1)->GetTotalPages();
99839     } catch (std::out_of_range& e) {
99840       {
99841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99842       };
99843     } catch (std::exception& e) {
99844       {
99845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99846       };
99847     } catch (Dali::DaliException e) {
99848       {
99849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99850       };
99851     } catch (...) {
99852       {
99853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99854       };
99855     }
99856   }
99857
99858   jresult = result;
99859   return jresult;
99860 }
99861
99862
99863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99864   int jresult ;
99865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99866   Dali::Toolkit::Ruler::RulerType result;
99867
99868   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99869   {
99870     try {
99871       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99872     } catch (std::out_of_range& e) {
99873       {
99874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99875       };
99876     } catch (std::exception& e) {
99877       {
99878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99879       };
99880     } catch (Dali::DaliException e) {
99881       {
99882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99883       };
99884     } catch (...) {
99885       {
99886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99887       };
99888     }
99889   }
99890
99891   jresult = (int)result;
99892   return jresult;
99893 }
99894
99895
99896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99897   unsigned int jresult ;
99898   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99899   bool result;
99900
99901   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99902   {
99903     try {
99904       result = (bool)(*arg1)->IsEnabled();
99905     } catch (std::out_of_range& e) {
99906       {
99907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99908       };
99909     } catch (std::exception& e) {
99910       {
99911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99912       };
99913     } catch (Dali::DaliException e) {
99914       {
99915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99916       };
99917     } catch (...) {
99918       {
99919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99920       };
99921     }
99922   }
99923
99924   jresult = result;
99925   return jresult;
99926 }
99927
99928
99929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99930   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99931
99932   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99933   {
99934     try {
99935       (*arg1)->Enable();
99936     } catch (std::out_of_range& e) {
99937       {
99938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99939       };
99940     } catch (std::exception& e) {
99941       {
99942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99943       };
99944     } catch (Dali::DaliException e) {
99945       {
99946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99947       };
99948     } catch (...) {
99949       {
99950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99951       };
99952     }
99953   }
99954
99955 }
99956
99957
99958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99960
99961   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99962   {
99963     try {
99964       (*arg1)->Disable();
99965     } catch (std::out_of_range& e) {
99966       {
99967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99968       };
99969     } catch (std::exception& e) {
99970       {
99971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99972       };
99973     } catch (Dali::DaliException e) {
99974       {
99975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99976       };
99977     } catch (...) {
99978       {
99979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99980       };
99981     }
99982   }
99983
99984 }
99985
99986
99987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99988   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99989   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99990   Dali::Toolkit::RulerDomain *argp2 ;
99991
99992   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99993   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99994   if (!argp2) {
99995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99996     return ;
99997   }
99998   arg2 = *argp2;
99999   {
100000     try {
100001       (*arg1)->SetDomain(arg2);
100002     } catch (std::out_of_range& e) {
100003       {
100004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100005       };
100006     } catch (std::exception& e) {
100007       {
100008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100009       };
100010     } catch (Dali::DaliException e) {
100011       {
100012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100013       };
100014     } catch (...) {
100015       {
100016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100017       };
100018     }
100019   }
100020
100021 }
100022
100023
100024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100025   void * jresult ;
100026   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100027   Dali::Toolkit::RulerDomain *result = 0 ;
100028
100029   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100030   {
100031     try {
100032       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100033     } catch (std::out_of_range& e) {
100034       {
100035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100036       };
100037     } catch (std::exception& e) {
100038       {
100039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100040       };
100041     } catch (Dali::DaliException e) {
100042       {
100043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100044       };
100045     } catch (...) {
100046       {
100047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100048       };
100049     }
100050   }
100051
100052   jresult = (void *)result;
100053   return jresult;
100054 }
100055
100056
100057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100058   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100059
100060   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100061   {
100062     try {
100063       (*arg1)->DisableDomain();
100064     } catch (std::out_of_range& e) {
100065       {
100066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100067       };
100068     } catch (std::exception& e) {
100069       {
100070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100071       };
100072     } catch (Dali::DaliException e) {
100073       {
100074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100075       };
100076     } catch (...) {
100077       {
100078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100079       };
100080     }
100081   }
100082
100083 }
100084
100085
100086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100087   float jresult ;
100088   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100089   float arg2 ;
100090   float arg3 ;
100091   float arg4 ;
100092   float result;
100093
100094   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100095   arg2 = (float)jarg2;
100096   arg3 = (float)jarg3;
100097   arg4 = (float)jarg4;
100098   {
100099     try {
100100       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100101     } catch (std::out_of_range& e) {
100102       {
100103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100104       };
100105     } catch (std::exception& e) {
100106       {
100107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100108       };
100109     } catch (Dali::DaliException e) {
100110       {
100111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100112       };
100113     } catch (...) {
100114       {
100115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100116       };
100117     }
100118   }
100119
100120   jresult = result;
100121   return jresult;
100122 }
100123
100124
100125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100126   float jresult ;
100127   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100128   float arg2 ;
100129   float arg3 ;
100130   float result;
100131
100132   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100133   arg2 = (float)jarg2;
100134   arg3 = (float)jarg3;
100135   {
100136     try {
100137       result = (float)(*arg1)->Clamp(arg2,arg3);
100138     } catch (std::out_of_range& e) {
100139       {
100140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100141       };
100142     } catch (std::exception& e) {
100143       {
100144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100145       };
100146     } catch (Dali::DaliException e) {
100147       {
100148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100149       };
100150     } catch (...) {
100151       {
100152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100153       };
100154     }
100155   }
100156
100157   jresult = result;
100158   return jresult;
100159 }
100160
100161
100162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100163   float jresult ;
100164   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100165   float arg2 ;
100166   float result;
100167
100168   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100169   arg2 = (float)jarg2;
100170   {
100171     try {
100172       result = (float)(*arg1)->Clamp(arg2);
100173     } catch (std::out_of_range& e) {
100174       {
100175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100176       };
100177     } catch (std::exception& e) {
100178       {
100179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100180       };
100181     } catch (Dali::DaliException e) {
100182       {
100183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100184       };
100185     } catch (...) {
100186       {
100187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100188       };
100189     }
100190   }
100191
100192   jresult = result;
100193   return jresult;
100194 }
100195
100196
100197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100198   float jresult ;
100199   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100200   float arg2 ;
100201   float arg3 ;
100202   float arg4 ;
100203   Dali::Toolkit::ClampState *arg5 = 0 ;
100204   float result;
100205
100206   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100207   arg2 = (float)jarg2;
100208   arg3 = (float)jarg3;
100209   arg4 = (float)jarg4;
100210   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100211   if (!arg5) {
100212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100213     return 0;
100214   }
100215   {
100216     try {
100217       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100218     } catch (std::out_of_range& e) {
100219       {
100220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100221       };
100222     } catch (std::exception& e) {
100223       {
100224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100225       };
100226     } catch (Dali::DaliException e) {
100227       {
100228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100229       };
100230     } catch (...) {
100231       {
100232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100233       };
100234     }
100235   }
100236
100237   jresult = result;
100238   return jresult;
100239 }
100240
100241
100242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100243   float jresult ;
100244   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100245   float arg2 ;
100246   float arg3 ;
100247   float arg4 ;
100248   float arg5 ;
100249   float result;
100250
100251   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100252   arg2 = (float)jarg2;
100253   arg3 = (float)jarg3;
100254   arg4 = (float)jarg4;
100255   arg5 = (float)jarg5;
100256   {
100257     try {
100258       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100259     } catch (std::out_of_range& e) {
100260       {
100261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100262       };
100263     } catch (std::exception& e) {
100264       {
100265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100266       };
100267     } catch (Dali::DaliException e) {
100268       {
100269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100270       };
100271     } catch (...) {
100272       {
100273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100274       };
100275     }
100276   }
100277
100278   jresult = result;
100279   return jresult;
100280 }
100281
100282
100283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100284   float jresult ;
100285   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100286   float arg2 ;
100287   float arg3 ;
100288   float arg4 ;
100289   float result;
100290
100291   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100292   arg2 = (float)jarg2;
100293   arg3 = (float)jarg3;
100294   arg4 = (float)jarg4;
100295   {
100296     try {
100297       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100298     } catch (std::out_of_range& e) {
100299       {
100300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100301       };
100302     } catch (std::exception& e) {
100303       {
100304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100305       };
100306     } catch (Dali::DaliException e) {
100307       {
100308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100309       };
100310     } catch (...) {
100311       {
100312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100313       };
100314     }
100315   }
100316
100317   jresult = result;
100318   return jresult;
100319 }
100320
100321
100322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100323   float jresult ;
100324   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100325   float arg2 ;
100326   float arg3 ;
100327   float result;
100328
100329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100330   arg2 = (float)jarg2;
100331   arg3 = (float)jarg3;
100332   {
100333     try {
100334       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100335     } catch (std::out_of_range& e) {
100336       {
100337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100338       };
100339     } catch (std::exception& e) {
100340       {
100341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100342       };
100343     } catch (Dali::DaliException e) {
100344       {
100345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100346       };
100347     } catch (...) {
100348       {
100349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100350       };
100351     }
100352   }
100353
100354   jresult = result;
100355   return jresult;
100356 }
100357
100358
100359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100360   float jresult ;
100361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100362   float arg2 ;
100363   float result;
100364
100365   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100366   arg2 = (float)jarg2;
100367   {
100368     try {
100369       result = (float)(*arg1)->SnapAndClamp(arg2);
100370     } catch (std::out_of_range& e) {
100371       {
100372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100373       };
100374     } catch (std::exception& e) {
100375       {
100376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100377       };
100378     } catch (Dali::DaliException e) {
100379       {
100380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100381       };
100382     } catch (...) {
100383       {
100384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100385       };
100386     }
100387   }
100388
100389   jresult = result;
100390   return jresult;
100391 }
100392
100393
100394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100395   float jresult ;
100396   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100397   float arg2 ;
100398   float arg3 ;
100399   float arg4 ;
100400   float arg5 ;
100401   Dali::Toolkit::ClampState *arg6 = 0 ;
100402   float result;
100403
100404   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100405   arg2 = (float)jarg2;
100406   arg3 = (float)jarg3;
100407   arg4 = (float)jarg4;
100408   arg5 = (float)jarg5;
100409   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100410   if (!arg6) {
100411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100412     return 0;
100413   }
100414   {
100415     try {
100416       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100417     } catch (std::out_of_range& e) {
100418       {
100419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100420       };
100421     } catch (std::exception& e) {
100422       {
100423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100424       };
100425     } catch (Dali::DaliException e) {
100426       {
100427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100428       };
100429     } catch (...) {
100430       {
100431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100432       };
100433     }
100434   }
100435
100436   jresult = result;
100437   return jresult;
100438 }
100439
100440
100441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100442   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100443
100444   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100445   {
100446     try {
100447       (*arg1)->Reference();
100448     } catch (std::out_of_range& e) {
100449       {
100450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100451       };
100452     } catch (std::exception& e) {
100453       {
100454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100455       };
100456     } catch (Dali::DaliException e) {
100457       {
100458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100459       };
100460     } catch (...) {
100461       {
100462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100463       };
100464     }
100465   }
100466
100467 }
100468
100469
100470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100471   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100472
100473   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100474   {
100475     try {
100476       (*arg1)->Unreference();
100477     } catch (std::out_of_range& e) {
100478       {
100479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100480       };
100481     } catch (std::exception& e) {
100482       {
100483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100484       };
100485     } catch (Dali::DaliException e) {
100486       {
100487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100488       };
100489     } catch (...) {
100490       {
100491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100492       };
100493     }
100494   }
100495
100496 }
100497
100498
100499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100500   int jresult ;
100501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100502   int result;
100503
100504   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100505   {
100506     try {
100507       result = (int)(*arg1)->ReferenceCount();
100508     } catch (std::out_of_range& e) {
100509       {
100510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100511       };
100512     } catch (std::exception& e) {
100513       {
100514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100515       };
100516     } catch (Dali::DaliException e) {
100517       {
100518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100519       };
100520     } catch (...) {
100521       {
100522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100523       };
100524     }
100525   }
100526
100527   jresult = result;
100528   return jresult;
100529 }
100530
100531
100532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100533   unsigned int jresult ;
100534   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100535   bool result;
100536
100537   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100538   {
100539     try {
100540       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100541     } catch (std::out_of_range& e) {
100542       {
100543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100544       };
100545     } catch (std::exception& e) {
100546       {
100547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100548       };
100549     } catch (Dali::DaliException e) {
100550       {
100551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100552       };
100553     } catch (...) {
100554       {
100555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100556       };
100557     }
100558   }
100559
100560   jresult = result;
100561   return jresult;
100562 }
100563
100564
100565 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100566   unsigned long jresult ;
100567   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100568   std::size_t result;
100569
100570   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100571   {
100572     try {
100573       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100574     } catch (std::out_of_range& e) {
100575       {
100576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100577       };
100578     } catch (std::exception& e) {
100579       {
100580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100581       };
100582     } catch (Dali::DaliException e) {
100583       {
100584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100585       };
100586     } catch (...) {
100587       {
100588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100589       };
100590     }
100591   }
100592
100593   jresult = (unsigned long)result;
100594   return jresult;
100595 }
100596
100597
100598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100599   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100600   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100601
100602   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100603   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100604   {
100605     try {
100606       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100607     } catch (std::out_of_range& e) {
100608       {
100609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100610       };
100611     } catch (std::exception& e) {
100612       {
100613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100614       };
100615     } catch (Dali::DaliException e) {
100616       {
100617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100618       };
100619     } catch (...) {
100620       {
100621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100622       };
100623     }
100624   }
100625
100626 }
100627
100628
100629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100630   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100631   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100632
100633   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100634   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100635   {
100636     try {
100637       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100638     } catch (std::out_of_range& e) {
100639       {
100640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100641       };
100642     } catch (std::exception& e) {
100643       {
100644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100645       };
100646     } catch (Dali::DaliException e) {
100647       {
100648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100649       };
100650     } catch (...) {
100651       {
100652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100653       };
100654     }
100655   }
100656
100657 }
100658
100659
100660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100661   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100662   Dali::Toolkit::Control arg2 ;
100663   Dali::Toolkit::Control *argp2 ;
100664
100665   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100666   argp2 = (Dali::Toolkit::Control *)jarg2;
100667   if (!argp2) {
100668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100669     return ;
100670   }
100671   arg2 = *argp2;
100672   {
100673     try {
100674       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100675     } catch (std::out_of_range& e) {
100676       {
100677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100678       };
100679     } catch (std::exception& e) {
100680       {
100681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100682       };
100683     } catch (Dali::DaliException e) {
100684       {
100685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100686       };
100687     } catch (...) {
100688       {
100689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100690       };
100691     }
100692   }
100693
100694 }
100695
100696
100697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100698   void * jresult ;
100699   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100700
100701   {
100702     try {
100703       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100704     } catch (std::out_of_range& e) {
100705       {
100706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100707       };
100708     } catch (std::exception& e) {
100709       {
100710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100711       };
100712     } catch (Dali::DaliException e) {
100713       {
100714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100715       };
100716     } catch (...) {
100717       {
100718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100719       };
100720     }
100721   }
100722
100723   jresult = (void *)result;
100724   return jresult;
100725 }
100726
100727
100728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100729   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100730
100731   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100732   {
100733     try {
100734       delete arg1;
100735     } catch (std::out_of_range& e) {
100736       {
100737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100738       };
100739     } catch (std::exception& e) {
100740       {
100741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100742       };
100743     } catch (Dali::DaliException e) {
100744       {
100745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100746       };
100747     } catch (...) {
100748       {
100749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100750       };
100751     }
100752   }
100753
100754 }
100755
100756 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100757   Dali::RefObject *result = NULL;
100758
100759   if (arg1)
100760   {
100761     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100762   }
100763   return result;
100764 }
100765
100766 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100767     return (Dali::RefObject *)jarg1;
100768 }
100769
100770 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100771     return (Dali::SignalObserver *)jarg1;
100772 }
100773
100774 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100775     return (Dali::ConnectionTrackerInterface *)jarg1;
100776 }
100777
100778 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100779     return (Dali::BaseHandle *)jarg1;
100780 }
100781
100782 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100783     return (Dali::BaseHandle *)jarg1;
100784 }
100785
100786 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100787     return (Dali::BaseHandle *)jarg1;
100788 }
100789
100790 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100791     return (Dali::BaseHandle *)jarg1;
100792 }
100793
100794 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100795     return (Dali::BaseHandle *)jarg1;
100796 }
100797
100798 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100799     return (Dali::BaseHandle *)jarg1;
100800 }
100801
100802 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100803     return (Dali::BaseHandle *)jarg1;
100804 }
100805
100806 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100807     return (Dali::BaseHandle *)jarg1;
100808 }
100809
100810 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100811     return (Dali::BaseHandle *)jarg1;
100812 }
100813
100814 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100815     return (Dali::BaseHandle *)jarg1;
100816 }
100817
100818 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100819     return (Dali::BaseHandle *)jarg1;
100820 }
100821
100822 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100823     return (Dali::BaseHandle *)jarg1;
100824 }
100825
100826 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100827     return (Dali::BaseHandle *)jarg1;
100828 }
100829
100830 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100831     return (Dali::Handle *)jarg1;
100832 }
100833
100834 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100835     return (Dali::Handle *)jarg1;
100836 }
100837
100838 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100839     return (Dali::BaseHandle *)jarg1;
100840 }
100841
100842 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100843     return (Dali::BaseHandle *)jarg1;
100844 }
100845
100846 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100847     return (Dali::Handle *)jarg1;
100848 }
100849
100850 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100851     return (Dali::BaseHandle *)jarg1;
100852 }
100853
100854 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100855     return (Dali::Handle *)jarg1;
100856 }
100857
100858 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100859     return (Dali::GestureDetector *)jarg1;
100860 }
100861
100862 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100863     return (Dali::Gesture *)jarg1;
100864 }
100865
100866 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100867     return (Dali::Handle *)jarg1;
100868 }
100869
100870 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100871     return (Dali::Actor *)jarg1;
100872 }
100873
100874 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100875     return (Dali::BaseHandle *)jarg1;
100876 }
100877
100878 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100879     return (Dali::RefObject *)jarg1;
100880 }
100881
100882 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100883     return (Dali::Actor *)jarg1;
100884 }
100885
100886 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100887     return (Dali::GestureDetector *)jarg1;
100888 }
100889
100890 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100891     return (Dali::Gesture *)jarg1;
100892 }
100893
100894 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100895     return (Dali::GestureDetector *)jarg1;
100896 }
100897
100898 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100899     return (Dali::Gesture *)jarg1;
100900 }
100901
100902 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100903     return (Dali::GestureDetector *)jarg1;
100904 }
100905
100906 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100907     return (Dali::Gesture *)jarg1;
100908 }
100909
100910 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100911     return (Dali::BaseHandle *)jarg1;
100912 }
100913
100914 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100915     return (Dali::Handle *)jarg1;
100916 }
100917
100918 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100919     return (Dali::Handle *)jarg1;
100920 }
100921
100922 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100923     return (Dali::Handle *)jarg1;
100924 }
100925
100926 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100927     return (Dali::Image *)jarg1;
100928 }
100929
100930 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100931     return (Dali::Image *)jarg1;
100932 }
100933
100934 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100935     return (Dali::Image *)jarg1;
100936 }
100937
100938 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100939     return (Dali::RefObject *)jarg1;
100940 }
100941
100942 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100943     return (Dali::Image *)jarg1;
100944 }
100945
100946 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100947     return (Dali::Image *)jarg1;
100948 }
100949
100950 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100951     return (Dali::ResourceImage *)jarg1;
100952 }
100953
100954 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100955     return (Dali::Actor *)jarg1;
100956 }
100957
100958 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100959     return (Dali::BaseHandle *)jarg1;
100960 }
100961
100962 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100963     return (Dali::BaseHandle *)jarg1;
100964 }
100965
100966
100967 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100968     return (Dali::BaseHandle *)jarg1;
100969 }
100970
100971 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100972     return (Dali::BaseHandle *)jarg1;
100973 }
100974
100975 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100976     return (Dali::CustomActorImpl *)jarg1;
100977 }
100978
100979 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100980     return (Dali::CustomActor *)jarg1;
100981 }
100982
100983 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100984     return (Dali::BaseHandle *)jarg1;
100985 }
100986
100987 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100988     return (Dali::Toolkit::Control *)jarg1;
100989 }
100990
100991 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100992     return (Dali::Toolkit::Control *)jarg1;
100993 }
100994
100995 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100996     return (Dali::Toolkit::Button *)jarg1;
100997 }
100998
100999 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101000     return (Dali::Toolkit::Button *)jarg1;
101001 }
101002
101003 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101004     return (Dali::Toolkit::Button *)jarg1;
101005 }
101006
101007 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101008     return (Dali::Toolkit::Control *)jarg1;
101009 }
101010
101011 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101012     return (Dali::Toolkit::Control *)jarg1;
101013 }
101014
101015 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101016     return (Dali::Toolkit::Control *)jarg1;
101017 }
101018
101019 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101020     return (Dali::Toolkit::Control *)jarg1;
101021 }
101022
101023 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101024     return (Dali::Toolkit::Control *)jarg1;
101025 }
101026
101027 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101028     return (Dali::RefObject *)jarg1;
101029 }
101030
101031 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101032     return (Dali::Toolkit::Scrollable *)jarg1;
101033 }
101034
101035 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101036     return (Dali::BaseHandle *)jarg1;
101037 }
101038
101039 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101040     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101041 }
101042
101043 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101044     return (Dali::RefObject *)jarg1;
101045 }
101046
101047 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101048     return (Dali::Toolkit::Ruler *)jarg1;
101049 }
101050
101051 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101052     return (Dali::Toolkit::Ruler *)jarg1;
101053 }
101054
101055 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101056     return (Dali::Toolkit::Scrollable *)jarg1;
101057 }
101058
101059 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101060     return (Dali::Toolkit::Control *)jarg1;
101061 }
101062
101063
101064 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101065     return (Dali::Toolkit::Control *)jarg1;
101066 }
101067
101068 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101069     return (Dali::BaseHandle *)jarg1;
101070 }
101071
101072 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101073     return (Dali::BaseHandle *)jarg1;
101074 }
101075
101076 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101077     return (Dali::Toolkit::Control *)jarg1;
101078 }
101079
101080 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101081     return (Dali::Toolkit::Control *)jarg1;
101082 }
101083
101084 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101085     return (Dali::Toolkit::Control *)jarg1;
101086 }
101087
101088 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101089     return (Dali::Toolkit::Control *)jarg1;
101090 }
101091
101092 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101093     return (Dali::Toolkit::Control *)jarg1;
101094 }
101095
101096 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101097     return (Dali::Toolkit::Control *)jarg1;
101098 }
101099
101100 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101101     return (Dali::Toolkit::PageTurnView *)jarg1;
101102 }
101103
101104 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101105     return (Dali::Toolkit::PageTurnView *)jarg1;
101106 }
101107
101108 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101109     return (Dali::Toolkit::Button *)jarg1;
101110 }
101111
101112 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101113     return (Dali::BaseHandle *)jarg1;
101114 }
101115
101116 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101117     return (Dali::BaseHandle *)jarg1;
101118 }
101119
101120 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101121     return (Dali::BaseHandle *)jarg1;
101122 }
101123
101124 /*
101125  * Widget binding
101126  */
101127 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101128     return (Dali::BaseHandle *)jarg1;
101129 }
101130
101131 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101132     return (Dali::BaseObject *)jarg1;
101133 }
101134
101135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101136   void * jresult ;
101137   Dali::Widget result;
101138
101139   {
101140     try {
101141       result = Dali::Widget::New();
101142     } catch (std::out_of_range& e) {
101143       {
101144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101145       };
101146     } catch (std::exception& e) {
101147       {
101148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101149       };
101150     } catch (...) {
101151       {
101152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101153       };
101154     }
101155   }
101156   jresult = new Dali::Widget((const Dali::Widget &)result);
101157   return jresult;
101158 }
101159
101160
101161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101162   void * jresult ;
101163   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101164   Dali::Widget result;
101165
101166   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101167
101168   if (!arg1) {
101169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101170     return 0;
101171   }
101172   {
101173     try {
101174       jresult = new Dali::Widget(arg1);
101175     } catch (std::out_of_range& e) {
101176       {
101177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101178       };
101179     } catch (std::exception& e) {
101180       {
101181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101182       };
101183     } catch (...) {
101184       {
101185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101186       };
101187     }
101188   }
101189   return jresult;
101190 }
101191
101192
101193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101194   void * jresult ;
101195   Dali::Widget *result = 0 ;
101196
101197   {
101198     try {
101199       result = (Dali::Widget *)new Dali::Widget();
101200     } catch (std::out_of_range& e) {
101201       {
101202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101203       };
101204     } catch (std::exception& e) {
101205       {
101206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101207       };
101208     } catch (...) {
101209       {
101210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101211       };
101212     }
101213   }
101214   jresult = (void *)result;
101215   return jresult;
101216 }
101217
101218
101219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101220   void * jresult ;
101221   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101222   Dali::Widget *arg2 = 0 ;
101223   Dali::Widget *result = 0 ;
101224
101225   arg1 = (Dali::Widget *)jarg1;
101226   arg2 = (Dali::Widget *)jarg2;
101227   if (!arg2) {
101228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101229     return 0;
101230   }
101231   {
101232     try {
101233       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101234     } catch (std::out_of_range& e) {
101235       {
101236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101237       };
101238     } catch (std::exception& e) {
101239       {
101240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101241       };
101242     } catch (...) {
101243       {
101244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101245       };
101246     }
101247   }
101248   jresult = (void *)result;
101249   return jresult;
101250 }
101251
101252
101253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101254   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101255
101256   arg1 = (Dali::Widget *)jarg1;
101257   {
101258     try {
101259       delete arg1;
101260     } catch (std::out_of_range& e) {
101261       {
101262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101263       };
101264     } catch (std::exception& e) {
101265       {
101266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101267       };
101268     } catch (...) {
101269       {
101270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101271       };
101272     }
101273   }
101274 }
101275
101276
101277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101278   void * jresult ;
101279   SwigDirector_WidgetImpl* result;
101280   {
101281     try {
101282       result = new SwigDirector_WidgetImpl();
101283     } catch (std::out_of_range& e) {
101284       {
101285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101286       };
101287     } catch (std::exception& e) {
101288       {
101289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101290       };
101291     } catch (...) {
101292       {
101293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101294       };
101295     }
101296   }
101297   jresult = result;
101298   return jresult;
101299 }
101300
101301
101302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101303   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101304   std::string *arg2 = 0 ;
101305   Dali::Window arg3 ;
101306   Dali::Window *argp3 ;
101307
101308   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101309   if (!jarg2) {
101310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101311     return ;
101312   }
101313   std::string arg2_str(jarg2);
101314   arg2 = &arg2_str;
101315   argp3 = (Dali::Window *)jarg3;
101316   if (!argp3) {
101317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101318     return ;
101319   }
101320   arg3 = *argp3;
101321   {
101322     try {
101323       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101324     } catch (std::out_of_range& e) {
101325       {
101326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101327       };
101328     } catch (std::exception& e) {
101329       {
101330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101331       };
101332     } catch (...) {
101333       {
101334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101335       };
101336     }
101337   }
101338 }
101339
101340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101341   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101342   std::string *arg2 = 0 ;
101343   Dali::Window arg3 ;
101344   Dali::Window *argp3 ;
101345
101346   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101347   if (!jarg2) {
101348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101349     return ;
101350   }
101351   std::string arg2_str(jarg2);
101352   arg2 = &arg2_str;
101353   argp3 = (Dali::Window *)jarg3;
101354   if (!argp3) {
101355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101356     return ;
101357   }
101358   arg3 = *argp3;
101359   {
101360     try {
101361       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101362     } catch (std::out_of_range& e) {
101363       {
101364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101365       };
101366     } catch (std::exception& e) {
101367       {
101368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101369       };
101370     } catch (...) {
101371       {
101372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101373       };
101374     }
101375   }
101376 }
101377
101378
101379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101380   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101381   std::string *arg2 = 0 ;
101382   Dali::Widget::Termination arg3 ;
101383
101384   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101385   if (!jarg2) {
101386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101387     return ;
101388   }
101389   std::string arg2_str(jarg2);
101390   arg2 = &arg2_str;
101391   arg3 = (Dali::Widget::Termination)jarg3;
101392   {
101393     try {
101394       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101395     } catch (std::out_of_range& e) {
101396       {
101397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101398       };
101399     } catch (std::exception& e) {
101400       {
101401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101402       };
101403     } catch (...) {
101404       {
101405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101406       };
101407     }
101408   }
101409 }
101410
101411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101412   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101413   std::string *arg2 = 0 ;
101414   Dali::Widget::Termination arg3 ;
101415
101416   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101417   if (!jarg2) {
101418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101419     return ;
101420   }
101421   std::string arg2_str(jarg2);
101422   arg2 = &arg2_str;
101423   arg3 = (Dali::Widget::Termination)jarg3;
101424   {
101425     try {
101426       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101427     } catch (std::out_of_range& e) {
101428       {
101429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101430       };
101431     } catch (std::exception& e) {
101432       {
101433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101434       };
101435     } catch (...) {
101436       {
101437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101438       };
101439     }
101440   }
101441 }
101442
101443
101444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101445   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101446
101447   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101448   {
101449     try {
101450       (arg1)->OnPause();
101451     } catch (std::out_of_range& e) {
101452       {
101453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101454       };
101455     } catch (std::exception& e) {
101456       {
101457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101458       };
101459     } catch (...) {
101460       {
101461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101462       };
101463     }
101464   }
101465 }
101466
101467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101468   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101469
101470   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101471   {
101472     try {
101473       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101474     } catch (std::out_of_range& e) {
101475       {
101476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101477       };
101478     } catch (std::exception& e) {
101479       {
101480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101481       };
101482     } catch (...) {
101483       {
101484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101485       };
101486     }
101487   }
101488 }
101489
101490
101491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101492   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101493
101494   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101495   {
101496     try {
101497       (arg1)->OnResume();
101498     } catch (std::out_of_range& e) {
101499       {
101500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101501       };
101502     } catch (std::exception& e) {
101503       {
101504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101505       };
101506     } catch (...) {
101507       {
101508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101509       };
101510     }
101511   }
101512 }
101513
101514
101515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101516   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101517
101518   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101519   {
101520     try {
101521       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101522     } catch (std::out_of_range& e) {
101523       {
101524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101525       };
101526     } catch (std::exception& e) {
101527       {
101528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101529       };
101530     } catch (...) {
101531       {
101532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101533       };
101534     }
101535   }
101536 }
101537
101538
101539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101540   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101541   Dali::Window arg2 ;
101542   Dali::Window *argp2 ;
101543
101544   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101545   argp2 = (Dali::Window *)jarg2;
101546   if (!argp2) {
101547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101548     return ;
101549   }
101550   arg2 = *argp2;
101551   {
101552     try {
101553       (arg1)->OnResize(arg2);
101554     } catch (std::out_of_range& e) {
101555       {
101556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101557       };
101558     } catch (std::exception& e) {
101559       {
101560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101561       };
101562     } catch (...) {
101563       {
101564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101565       };
101566     }
101567   }
101568 }
101569
101570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101571   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101572   Dali::Window arg2 ;
101573   Dali::Window *argp2 ;
101574
101575   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101576   argp2 = (Dali::Window *)jarg2;
101577   if (!argp2) {
101578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101579     return ;
101580   }
101581   arg2 = *argp2;
101582   {
101583     try {
101584       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101585     } catch (std::out_of_range& e) {
101586       {
101587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101588       };
101589     } catch (std::exception& e) {
101590       {
101591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101592       };
101593     } catch (...) {
101594       {
101595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101596       };
101597     }
101598   }
101599 }
101600
101601
101602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101603   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101604   std::string *arg2 = 0 ;
101605   int arg3 ;
101606
101607   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101608   if (!jarg2) {
101609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101610     return ;
101611   }
101612   std::string arg2_str(jarg2);
101613   arg2 = &arg2_str;
101614   arg3 = (int)jarg3;
101615   {
101616     try {
101617       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101618     } catch (std::out_of_range& e) {
101619       {
101620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101621       };
101622     } catch (std::exception& e) {
101623       {
101624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101625       };
101626     } catch (...) {
101627       {
101628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101629       };
101630     }
101631   }
101632 }
101633
101634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101635   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101636   std::string *arg2 = 0 ;
101637   int arg3 ;
101638
101639   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101640   if (!jarg2) {
101641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101642     return ;
101643   }
101644   std::string arg2_str(jarg2);
101645   arg2 = &arg2_str;
101646   arg3 = (int)jarg3;
101647   {
101648     try {
101649       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101650     } catch (std::out_of_range& e) {
101651       {
101652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101653       };
101654     } catch (std::exception& e) {
101655       {
101656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101657       };
101658     } catch (...) {
101659       {
101660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101661       };
101662     }
101663   }
101664 }
101665
101666
101667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101668   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101669   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101670   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101671
101672   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101673   arg2 = (Dali::SlotObserver *)jarg2;
101674   arg3 = (Dali::CallbackBase *)jarg3;
101675   {
101676     try {
101677       (arg1)->SignalConnected(arg2,arg3);
101678     } catch (std::out_of_range& e) {
101679       {
101680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101681       };
101682     } catch (std::exception& e) {
101683       {
101684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101685       };
101686     } catch (...) {
101687       {
101688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101689       };
101690     }
101691   }
101692 }
101693
101694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101695   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101696   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101697   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101698
101699   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101700   arg2 = (Dali::SlotObserver *)jarg2;
101701   arg3 = (Dali::CallbackBase *)jarg3;
101702   {
101703     try {
101704       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101705     } catch (std::out_of_range& e) {
101706       {
101707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101708       };
101709     } catch (std::exception& e) {
101710       {
101711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101712       };
101713     } catch (...) {
101714       {
101715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101716       };
101717     }
101718   }
101719 }
101720
101721
101722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101723   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101724   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101725   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101726
101727   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101728   arg2 = (Dali::SlotObserver *)jarg2;
101729   arg3 = (Dali::CallbackBase *)jarg3;
101730   {
101731     try {
101732       (arg1)->SignalDisconnected(arg2,arg3);
101733     } catch (std::out_of_range& e) {
101734       {
101735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101736       };
101737     } catch (std::exception& e) {
101738       {
101739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101740       };
101741     } catch (...) {
101742       {
101743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101744       };
101745     }
101746   }
101747 }
101748
101749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101750   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101751   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101752   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101753
101754   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101755   arg2 = (Dali::SlotObserver *)jarg2;
101756   arg3 = (Dali::CallbackBase *)jarg3;
101757   {
101758     try {
101759       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101760     } catch (std::out_of_range& e) {
101761       {
101762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101763       };
101764     } catch (std::exception& e) {
101765       {
101766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101767       };
101768     } catch (...) {
101769       {
101770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101771       };
101772     }
101773   }
101774 }
101775
101776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101777   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101778   std::string *arg2 = 0 ;
101779
101780   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101781   if (!jarg2) {
101782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101783     return ;
101784   }
101785   std::string arg2_str(jarg2);
101786   arg2 = &arg2_str;
101787   {
101788     try {
101789       (arg1)->SetContentInfo((std::string const &)*arg2);
101790     } catch (std::out_of_range& e) {
101791       {
101792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101793       };
101794     } catch (std::exception& e) {
101795       {
101796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101797       };
101798     } catch (...) {
101799       {
101800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101801       };
101802     }
101803   }
101804 }
101805
101806
101807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101808   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101809   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101810
101811   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101812   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101813   {
101814     try {
101815       (arg1)->SetImpl(arg2);
101816     } catch (std::out_of_range& e) {
101817       {
101818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101819       };
101820     } catch (std::exception& e) {
101821       {
101822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101823       };
101824     } catch (...) {
101825       {
101826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101827       };
101828     }
101829   }
101830 }
101831
101832 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) {
101833
101834   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101835   if (director) {
101836     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101837   }
101838 }
101839
101840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101841   void * jresult ;
101842   Dali::Widget *arg1 = 0 ;
101843   SwigDirector_WidgetImpl *result = 0 ;
101844
101845   arg1 = (Dali::Widget *)jarg1;
101846   if (!arg1) {
101847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101848     return 0;
101849   }
101850   {
101851     try {
101852       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101853     } catch (std::out_of_range& e) {
101854       {
101855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101856       };
101857     } catch (std::exception& e) {
101858       {
101859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101860       };
101861     } catch (...) {
101862       {
101863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101864       };
101865     }
101866   }
101867
101868   jresult = (void *)result;
101869   return jresult;
101870 }
101871
101872
101873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101874   void * jresult ;
101875   int *arg1 = (int *) 0 ;
101876   char ***arg2 ;
101877   std::string *arg3 = 0 ;
101878   Dali::WidgetApplication result;
101879   {
101880     int index = 0;
101881     int length = 0;
101882     char *retPtr;
101883     char *nextPtr;
101884     argWidgetC = jarg1;
101885     argWidgetV = new char*[jarg1 + 1];
101886
101887     retPtr = strtok_r( jarg2, " ", &nextPtr);
101888     if( retPtr )
101889     {
101890       length = strlen(retPtr);
101891     }
101892     argWidgetV[index] = new char[length + 1];
101893     if( retPtr )
101894     {
101895       strncpy(argWidgetV[index], retPtr, length);
101896     }
101897     argWidgetV[index][length] = '\0';
101898     index++;
101899
101900     while (index < jarg1)
101901     {
101902       length = 0;
101903       retPtr = strtok_r(NULL, " ", &nextPtr);
101904       if( retPtr )
101905       {
101906         length = strlen(retPtr);
101907       }
101908       argWidgetV[index] = new char[length + 1];
101909       if( retPtr )
101910       {
101911         strncpy(argWidgetV[index], retPtr, length);
101912       }
101913       argWidgetV[index][length] = '\0';
101914       index++;
101915     }
101916
101917     argWidgetV[jarg1] = NULL;
101918     argWidgetC = jarg1;
101919
101920     arg1 = &argWidgetC;
101921     arg2 = &argWidgetV;
101922   }
101923
101924   if (!jarg3) {
101925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101926     return 0;
101927   }
101928   std::string arg3_str(jarg3);
101929   arg3 = &arg3_str;
101930   {
101931     try {
101932       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101933     } catch (std::out_of_range& e) {
101934       {
101935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101936       };
101937     } catch (std::exception& e) {
101938       {
101939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101940       };
101941     } catch (...) {
101942       {
101943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101944       };
101945     }
101946   }
101947   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101948
101949   return jresult;
101950 }
101951
101952
101953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101954   void * jresult ;
101955   Dali::WidgetApplication *result = 0 ;
101956
101957   {
101958     try {
101959       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101960     } catch (std::out_of_range& e) {
101961       {
101962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101963       };
101964     } catch (std::exception& e) {
101965       {
101966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101967       };
101968     } catch (...) {
101969       {
101970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101971       };
101972     }
101973   }
101974   jresult = (void *)result;
101975   return jresult;
101976 }
101977
101978
101979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101980   void * jresult ;
101981   Dali::WidgetApplication *arg1 = 0 ;
101982   Dali::WidgetApplication *result = 0 ;
101983
101984   arg1 = (Dali::WidgetApplication *)jarg1;
101985   if (!arg1) {
101986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101987     return 0;
101988   }
101989   {
101990     try {
101991       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101992     } catch (std::out_of_range& e) {
101993       {
101994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101995       };
101996     } catch (std::exception& e) {
101997       {
101998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101999       };
102000     } catch (...) {
102001       {
102002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102003       };
102004     }
102005   }
102006   jresult = (void *)result;
102007   return jresult;
102008 }
102009
102010
102011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102012   void * jresult ;
102013   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102014   Dali::WidgetApplication *arg2 = 0 ;
102015   Dali::WidgetApplication *result = 0 ;
102016
102017   arg1 = (Dali::WidgetApplication *)jarg1;
102018   arg2 = (Dali::WidgetApplication *)jarg2;
102019   if (!arg2) {
102020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102021     return 0;
102022   }
102023   {
102024     try {
102025       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102026     } catch (std::out_of_range& e) {
102027       {
102028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102029       };
102030     } catch (std::exception& e) {
102031       {
102032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102033       };
102034     } catch (...) {
102035       {
102036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102037       };
102038     }
102039   }
102040   jresult = (void *)result;
102041   return jresult;
102042 }
102043
102044
102045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102046   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102047
102048   arg1 = (Dali::WidgetApplication *)jarg1;
102049   {
102050     try {
102051       delete arg1;
102052       if( argWidgetV )
102053       {
102054         // free string data
102055         for( int i=0; i < argWidgetC+1; i++)
102056         {
102057           delete [] argWidgetV[i];
102058         }
102059         delete [] argWidgetV;
102060       }
102061     } catch (std::out_of_range& e) {
102062       {
102063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102064       };
102065     } catch (std::exception& e) {
102066       {
102067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102068       };
102069     } catch (...) {
102070       {
102071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102072       };
102073     }
102074   }
102075 }
102076
102077
102078 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102079 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102080
102081 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102082 {
102083   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102084   return *widget;
102085 }
102086
102087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102088   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102089   std::string *arg2 = 0 ;
102090
102091   arg1 = (Dali::WidgetApplication *)jarg1;
102092   if (!jarg2) {
102093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102094     return ;
102095   }
102096   std::string arg2_str(*jarg2);
102097   arg2 = &arg2_str;
102098
102099   if(!_CSharpCreateWidgetFunction)
102100   {
102101     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102102   }
102103
102104   {
102105     try {
102106       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102107     } catch (std::out_of_range& e) {
102108       {
102109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102110       };
102111     } catch (std::exception& e) {
102112       {
102113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102114       };
102115     } catch (...) {
102116       {
102117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102118       };
102119     }
102120   }
102121
102122   //Typemap argout in c++ file.
102123   //This will convert c++ string to c# string
102124   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102125 }
102126
102127
102128 //for PixelBuffer and ImageLoading
102129
102130 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102131     return (Dali::BaseHandle *)jarg1;
102132 }
102133
102134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102135   void * jresult ;
102136   unsigned int arg1 ;
102137   unsigned int arg2 ;
102138   Dali::Pixel::Format arg3 ;
102139   Dali::Devel::PixelBuffer result;
102140
102141   arg1 = (unsigned int)jarg1;
102142   arg2 = (unsigned int)jarg2;
102143   arg3 = (Dali::Pixel::Format)jarg3;
102144   {
102145     try {
102146       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102147     } catch (std::out_of_range& e) {
102148       {
102149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102150       };
102151     } catch (std::exception& e) {
102152       {
102153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102154       };
102155     } catch (...) {
102156       {
102157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102158       };
102159     }
102160   }
102161   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102162   return jresult;
102163 }
102164
102165
102166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102167   void * jresult ;
102168   Dali::Devel::PixelBuffer *result = 0 ;
102169
102170   {
102171     try {
102172       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102173     } catch (std::out_of_range& e) {
102174       {
102175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102176       };
102177     } catch (std::exception& e) {
102178       {
102179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102180       };
102181     } catch (...) {
102182       {
102183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102184       };
102185     }
102186   }
102187   jresult = (void *)result;
102188   return jresult;
102189 }
102190
102191
102192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102193   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102194
102195   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102196   {
102197     try {
102198       delete arg1;
102199     } catch (std::out_of_range& e) {
102200       {
102201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102202       };
102203     } catch (std::exception& e) {
102204       {
102205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102206       };
102207     } catch (...) {
102208       {
102209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102210       };
102211     }
102212   }
102213 }
102214
102215
102216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102217   void * jresult ;
102218   Dali::Devel::PixelBuffer *arg1 = 0 ;
102219   Dali::Devel::PixelBuffer *result = 0 ;
102220
102221   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102222   if (!arg1) {
102223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102224     return 0;
102225   }
102226   {
102227     try {
102228       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102229     } catch (std::out_of_range& e) {
102230       {
102231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102232       };
102233     } catch (std::exception& e) {
102234       {
102235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102236       };
102237     } catch (...) {
102238       {
102239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102240       };
102241     }
102242   }
102243   jresult = (void *)result;
102244   return jresult;
102245 }
102246
102247
102248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102249   void * jresult ;
102250   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102251   Dali::Devel::PixelBuffer *arg2 = 0 ;
102252   Dali::Devel::PixelBuffer *result = 0 ;
102253
102254   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102255   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102256   if (!arg2) {
102257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102258     return 0;
102259   }
102260   {
102261     try {
102262       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102263     } catch (std::out_of_range& e) {
102264       {
102265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102266       };
102267     } catch (std::exception& e) {
102268       {
102269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102270       };
102271     } catch (...) {
102272       {
102273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102274       };
102275     }
102276   }
102277   jresult = (void *)result;
102278   return jresult;
102279 }
102280
102281
102282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102283   void * jresult ;
102284   Dali::Devel::PixelBuffer *arg1 = 0 ;
102285   Dali::PixelData result;
102286
102287   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102288   if (!arg1) {
102289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102290     return 0;
102291   }
102292   {
102293     try {
102294       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102295     } catch (std::out_of_range& e) {
102296       {
102297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102298       };
102299     } catch (std::exception& e) {
102300       {
102301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102302       };
102303     } catch (...) {
102304       {
102305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102306       };
102307     }
102308   }
102309   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102310   return jresult;
102311 }
102312
102313
102314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102315   void * jresult ;
102316   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102317   Dali::PixelData result;
102318
102319   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102320   {
102321     try {
102322       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102323     } catch (std::out_of_range& e) {
102324       {
102325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102326       };
102327     } catch (std::exception& e) {
102328       {
102329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102330       };
102331     } catch (...) {
102332       {
102333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102334       };
102335     }
102336   }
102337   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102338   return jresult;
102339 }
102340
102341
102342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102343   void * jresult ;
102344   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102345   unsigned char *result = 0 ;
102346
102347   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102348   {
102349     try {
102350       result = (unsigned char *)(arg1)->GetBuffer();
102351     } catch (std::out_of_range& e) {
102352       {
102353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102354       };
102355     } catch (std::exception& e) {
102356       {
102357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102358       };
102359     } catch (...) {
102360       {
102361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102362       };
102363     }
102364   }
102365   jresult = (void *)result;
102366   return jresult;
102367 }
102368
102369
102370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102371   unsigned int jresult ;
102372   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102373   unsigned int result;
102374
102375   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102376   {
102377     try {
102378       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102379     } catch (std::out_of_range& e) {
102380       {
102381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102382       };
102383     } catch (std::exception& e) {
102384       {
102385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102386       };
102387     } catch (...) {
102388       {
102389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102390       };
102391     }
102392   }
102393   jresult = result;
102394   return jresult;
102395 }
102396
102397
102398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102399   unsigned int jresult ;
102400   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102401   unsigned int result;
102402
102403   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102404   {
102405     try {
102406       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102407     } catch (std::out_of_range& e) {
102408       {
102409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102410       };
102411     } catch (std::exception& e) {
102412       {
102413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102414       };
102415     } catch (...) {
102416       {
102417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102418       };
102419     }
102420   }
102421   jresult = result;
102422   return jresult;
102423 }
102424
102425
102426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102427   int jresult ;
102428   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102429   Dali::Pixel::Format result;
102430
102431   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102432   {
102433     try {
102434       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102435     } catch (std::out_of_range& e) {
102436       {
102437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102438       };
102439     } catch (std::exception& e) {
102440       {
102441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102442       };
102443     } catch (...) {
102444       {
102445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102446       };
102447     }
102448   }
102449   jresult = (int)result;
102450   return jresult;
102451 }
102452
102453
102454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102455   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102456   Dali::Devel::PixelBuffer arg2 ;
102457   float arg3 ;
102458   bool arg4 ;
102459   Dali::Devel::PixelBuffer *argp2 ;
102460
102461   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102462   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102463   if (!argp2) {
102464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102465     return ;
102466   }
102467   arg2 = *argp2;
102468   arg3 = (float)jarg3;
102469   arg4 = jarg4 ? true : false;
102470   {
102471     try {
102472       (arg1)->ApplyMask(arg2,arg3,arg4);
102473     } catch (std::out_of_range& e) {
102474       {
102475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102476       };
102477     } catch (std::exception& e) {
102478       {
102479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102480       };
102481     } catch (...) {
102482       {
102483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102484       };
102485     }
102486   }
102487 }
102488
102489
102490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102491   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102492   Dali::Devel::PixelBuffer arg2 ;
102493   float arg3 ;
102494   Dali::Devel::PixelBuffer *argp2 ;
102495
102496   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102497   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102498   if (!argp2) {
102499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102500     return ;
102501   }
102502   arg2 = *argp2;
102503   arg3 = (float)jarg3;
102504   {
102505     try {
102506       (arg1)->ApplyMask(arg2,arg3);
102507     } catch (std::out_of_range& e) {
102508       {
102509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102510       };
102511     } catch (std::exception& e) {
102512       {
102513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102514       };
102515     } catch (...) {
102516       {
102517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102518       };
102519     }
102520   }
102521 }
102522
102523
102524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102525   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102526   Dali::Devel::PixelBuffer arg2 ;
102527   Dali::Devel::PixelBuffer *argp2 ;
102528
102529   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102530   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102531   if (!argp2) {
102532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102533     return ;
102534   }
102535   arg2 = *argp2;
102536   {
102537     try {
102538       (arg1)->ApplyMask(arg2);
102539     } catch (std::out_of_range& e) {
102540       {
102541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102542       };
102543     } catch (std::exception& e) {
102544       {
102545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102546       };
102547     } catch (...) {
102548       {
102549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102550       };
102551     }
102552   }
102553 }
102554
102555
102556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102557   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102558   float arg2 ;
102559
102560   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102561   arg2 = (float)jarg2;
102562   {
102563     try {
102564       (arg1)->ApplyGaussianBlur(arg2);
102565     } catch (std::out_of_range& e) {
102566       {
102567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102568       };
102569     } catch (std::exception& e) {
102570       {
102571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102572       };
102573     } catch (...) {
102574       {
102575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102576       };
102577     }
102578   }
102579 }
102580
102581
102582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102583   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102584   uint16_t arg2 ;
102585   uint16_t arg3 ;
102586   uint16_t arg4 ;
102587   uint16_t arg5 ;
102588
102589   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102590   arg2 = (uint16_t)jarg2;
102591   arg3 = (uint16_t)jarg3;
102592   arg4 = (uint16_t)jarg4;
102593   arg5 = (uint16_t)jarg5;
102594   {
102595     try {
102596       (arg1)->Crop(arg2,arg3,arg4,arg5);
102597     } catch (std::out_of_range& e) {
102598       {
102599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102600       };
102601     } catch (std::exception& e) {
102602       {
102603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102604       };
102605     } catch (...) {
102606       {
102607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102608       };
102609     }
102610   }
102611 }
102612
102613
102614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102615   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102616   uint16_t arg2 ;
102617   uint16_t arg3 ;
102618
102619   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102620   arg2 = (uint16_t)jarg2;
102621   arg3 = (uint16_t)jarg3;
102622   {
102623     try {
102624       (arg1)->Resize(arg2,arg3);
102625     } catch (std::out_of_range& e) {
102626       {
102627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102628       };
102629     } catch (std::exception& e) {
102630       {
102631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102632       };
102633     } catch (...) {
102634       {
102635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102636       };
102637     }
102638   }
102639 }
102640
102641
102642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102643   void * jresult ;
102644   std::string *arg1 = 0 ;
102645   Dali::ImageDimensions arg2 ;
102646   Dali::FittingMode::Type arg3 ;
102647   Dali::SamplingMode::Type arg4 ;
102648   bool arg5 ;
102649   Dali::ImageDimensions *argp2 ;
102650   Dali::Devel::PixelBuffer result;
102651
102652   if (!jarg1) {
102653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102654     return 0;
102655   }
102656   std::string arg1_str(jarg1);
102657   arg1 = &arg1_str;
102658   argp2 = (Dali::ImageDimensions *)jarg2;
102659   if (!argp2) {
102660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102661     return 0;
102662   }
102663   arg2 = *argp2;
102664   arg3 = (Dali::FittingMode::Type)jarg3;
102665   arg4 = (Dali::SamplingMode::Type)jarg4;
102666   arg5 = jarg5 ? true : false;
102667   {
102668     try {
102669       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102670     } catch (std::out_of_range& e) {
102671       {
102672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102673       };
102674     } catch (std::exception& e) {
102675       {
102676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102677       };
102678     } catch (...) {
102679       {
102680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102681       };
102682     }
102683   }
102684   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102685
102686   return jresult;
102687 }
102688
102689
102690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102691   void * jresult ;
102692   std::string *arg1 = 0 ;
102693   Dali::ImageDimensions arg2 ;
102694   Dali::FittingMode::Type arg3 ;
102695   Dali::SamplingMode::Type arg4 ;
102696   Dali::ImageDimensions *argp2 ;
102697   Dali::Devel::PixelBuffer result;
102698
102699   if (!jarg1) {
102700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102701     return 0;
102702   }
102703   std::string arg1_str(jarg1);
102704   arg1 = &arg1_str;
102705   argp2 = (Dali::ImageDimensions *)jarg2;
102706   if (!argp2) {
102707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102708     return 0;
102709   }
102710   arg2 = *argp2;
102711   arg3 = (Dali::FittingMode::Type)jarg3;
102712   arg4 = (Dali::SamplingMode::Type)jarg4;
102713   {
102714     try {
102715       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102716     } catch (std::out_of_range& e) {
102717       {
102718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102719       };
102720     } catch (std::exception& e) {
102721       {
102722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102723       };
102724     } catch (...) {
102725       {
102726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102727       };
102728     }
102729   }
102730   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102731
102732   return jresult;
102733 }
102734
102735
102736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102737   void * jresult ;
102738   std::string *arg1 = 0 ;
102739   Dali::ImageDimensions arg2 ;
102740   Dali::FittingMode::Type arg3 ;
102741   Dali::ImageDimensions *argp2 ;
102742   Dali::Devel::PixelBuffer result;
102743
102744   if (!jarg1) {
102745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102746     return 0;
102747   }
102748   std::string arg1_str(jarg1);
102749   arg1 = &arg1_str;
102750   argp2 = (Dali::ImageDimensions *)jarg2;
102751   if (!argp2) {
102752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102753     return 0;
102754   }
102755   arg2 = *argp2;
102756   arg3 = (Dali::FittingMode::Type)jarg3;
102757   {
102758     try {
102759       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102760     } catch (std::out_of_range& e) {
102761       {
102762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102763       };
102764     } catch (std::exception& e) {
102765       {
102766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102767       };
102768     } catch (...) {
102769       {
102770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102771       };
102772     }
102773   }
102774   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102775
102776   return jresult;
102777 }
102778
102779
102780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102781   void * jresult ;
102782   std::string *arg1 = 0 ;
102783   Dali::ImageDimensions arg2 ;
102784   Dali::ImageDimensions *argp2 ;
102785   Dali::Devel::PixelBuffer result;
102786
102787   if (!jarg1) {
102788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102789     return 0;
102790   }
102791   std::string arg1_str(jarg1);
102792   arg1 = &arg1_str;
102793   argp2 = (Dali::ImageDimensions *)jarg2;
102794   if (!argp2) {
102795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102796     return 0;
102797   }
102798   arg2 = *argp2;
102799   {
102800     try {
102801       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102802     } catch (std::out_of_range& e) {
102803       {
102804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102805       };
102806     } catch (std::exception& e) {
102807       {
102808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102809       };
102810     } catch (...) {
102811       {
102812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102813       };
102814     }
102815   }
102816   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102817
102818   return jresult;
102819 }
102820
102821
102822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102823   void * jresult ;
102824   std::string *arg1 = 0 ;
102825   Dali::Devel::PixelBuffer result;
102826
102827   if (!jarg1) {
102828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102829     return 0;
102830   }
102831   std::string arg1_str(jarg1);
102832   arg1 = &arg1_str;
102833   {
102834     try {
102835       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102836     } catch (std::out_of_range& e) {
102837       {
102838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102839       };
102840     } catch (std::exception& e) {
102841       {
102842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102843       };
102844     } catch (...) {
102845       {
102846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102847       };
102848     }
102849   }
102850   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102851
102852   return jresult;
102853 }
102854
102855
102856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102857   void * jresult ;
102858   std::string *arg1 = 0 ;
102859   Dali::ImageDimensions arg2 ;
102860   Dali::FittingMode::Type arg3 ;
102861   Dali::SamplingMode::Type arg4 ;
102862   bool arg5 ;
102863   Dali::ImageDimensions *argp2 ;
102864   Dali::ImageDimensions result;
102865
102866   if (!jarg1) {
102867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102868     return 0;
102869   }
102870   std::string arg1_str(jarg1);
102871   arg1 = &arg1_str;
102872   argp2 = (Dali::ImageDimensions *)jarg2;
102873   if (!argp2) {
102874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102875     return 0;
102876   }
102877   arg2 = *argp2;
102878   arg3 = (Dali::FittingMode::Type)jarg3;
102879   arg4 = (Dali::SamplingMode::Type)jarg4;
102880   arg5 = jarg5 ? true : false;
102881   {
102882     try {
102883       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102884     } catch (std::out_of_range& e) {
102885       {
102886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102887       };
102888     } catch (std::exception& e) {
102889       {
102890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102891       };
102892     } catch (...) {
102893       {
102894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102895       };
102896     }
102897   }
102898   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102899
102900   return jresult;
102901 }
102902
102903
102904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102905   void * jresult ;
102906   std::string *arg1 = 0 ;
102907   Dali::ImageDimensions arg2 ;
102908   Dali::FittingMode::Type arg3 ;
102909   Dali::SamplingMode::Type arg4 ;
102910   Dali::ImageDimensions *argp2 ;
102911   Dali::ImageDimensions result;
102912
102913   if (!jarg1) {
102914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102915     return 0;
102916   }
102917   std::string arg1_str(jarg1);
102918   arg1 = &arg1_str;
102919   argp2 = (Dali::ImageDimensions *)jarg2;
102920   if (!argp2) {
102921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102922     return 0;
102923   }
102924   arg2 = *argp2;
102925   arg3 = (Dali::FittingMode::Type)jarg3;
102926   arg4 = (Dali::SamplingMode::Type)jarg4;
102927   {
102928     try {
102929       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102930     } catch (std::out_of_range& e) {
102931       {
102932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102933       };
102934     } catch (std::exception& e) {
102935       {
102936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102937       };
102938     } catch (...) {
102939       {
102940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102941       };
102942     }
102943   }
102944   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102945
102946   return jresult;
102947 }
102948
102949
102950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102951   void * jresult ;
102952   std::string *arg1 = 0 ;
102953   Dali::ImageDimensions arg2 ;
102954   Dali::FittingMode::Type arg3 ;
102955   Dali::ImageDimensions *argp2 ;
102956   Dali::ImageDimensions result;
102957
102958   if (!jarg1) {
102959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102960     return 0;
102961   }
102962   std::string arg1_str(jarg1);
102963   arg1 = &arg1_str;
102964   argp2 = (Dali::ImageDimensions *)jarg2;
102965   if (!argp2) {
102966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102967     return 0;
102968   }
102969   arg2 = *argp2;
102970   arg3 = (Dali::FittingMode::Type)jarg3;
102971   {
102972     try {
102973       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102974     } catch (std::out_of_range& e) {
102975       {
102976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102977       };
102978     } catch (std::exception& e) {
102979       {
102980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102981       };
102982     } catch (...) {
102983       {
102984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102985       };
102986     }
102987   }
102988   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102989
102990   return jresult;
102991 }
102992
102993
102994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102995   void * jresult ;
102996   std::string *arg1 = 0 ;
102997   Dali::ImageDimensions arg2 ;
102998   Dali::ImageDimensions *argp2 ;
102999   Dali::ImageDimensions result;
103000
103001   if (!jarg1) {
103002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103003     return 0;
103004   }
103005   std::string arg1_str(jarg1);
103006   arg1 = &arg1_str;
103007   argp2 = (Dali::ImageDimensions *)jarg2;
103008   if (!argp2) {
103009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103010     return 0;
103011   }
103012   arg2 = *argp2;
103013   {
103014     try {
103015       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103016     } catch (std::out_of_range& e) {
103017       {
103018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103019       };
103020     } catch (std::exception& e) {
103021       {
103022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103023       };
103024     } catch (...) {
103025       {
103026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103027       };
103028     }
103029   }
103030   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103031
103032   return jresult;
103033 }
103034
103035
103036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103037   void * jresult ;
103038   std::string *arg1 = 0 ;
103039   Dali::ImageDimensions result;
103040
103041   if (!jarg1) {
103042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103043     return 0;
103044   }
103045   std::string arg1_str(jarg1);
103046   arg1 = &arg1_str;
103047   {
103048     try {
103049       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103050     } catch (std::out_of_range& e) {
103051       {
103052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103053       };
103054     } catch (std::exception& e) {
103055       {
103056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103057       };
103058     } catch (...) {
103059       {
103060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103061       };
103062     }
103063   }
103064   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103065
103066   return jresult;
103067 }
103068
103069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
103070   void * jresult ;
103071   std::string *arg1 = 0 ;
103072   Dali::ImageDimensions result;
103073
103074   if (!jarg1) {
103075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103076     return 0;
103077   }
103078   std::string arg1_str(jarg1);
103079   arg1 = &arg1_str;
103080   {
103081     try {
103082       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
103083     } catch (std::out_of_range& e) {
103084       {
103085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103086       };
103087     } catch (std::exception& e) {
103088       {
103089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103090       };
103091     } catch (...) {
103092       {
103093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103094       };
103095     }
103096   }
103097   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103098
103099   return jresult;
103100 }
103101
103102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103103   void * jresult ;
103104   std::string *arg1 = 0 ;
103105   Dali::ImageDimensions arg2 ;
103106   Dali::FittingMode::Type arg3 ;
103107   Dali::SamplingMode::Type arg4 ;
103108   bool arg5 ;
103109   Dali::ImageDimensions *argp2 ;
103110   Dali::Devel::PixelBuffer result;
103111
103112   if (!jarg1) {
103113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103114     return 0;
103115   }
103116   std::string arg1_str(jarg1);
103117   arg1 = &arg1_str;
103118   argp2 = (Dali::ImageDimensions *)jarg2;
103119   if (!argp2) {
103120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103121     return 0;
103122   }
103123   arg2 = *argp2;
103124   arg3 = (Dali::FittingMode::Type)jarg3;
103125   arg4 = (Dali::SamplingMode::Type)jarg4;
103126   arg5 = jarg5 ? true : false;
103127   {
103128     try {
103129       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103130     } catch (std::out_of_range& e) {
103131       {
103132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103133       };
103134     } catch (std::exception& e) {
103135       {
103136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103137       };
103138     } catch (...) {
103139       {
103140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103141       };
103142     }
103143   }
103144   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103145
103146   return jresult;
103147 }
103148
103149
103150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103151   void * jresult ;
103152   std::string *arg1 = 0 ;
103153   Dali::ImageDimensions arg2 ;
103154   Dali::FittingMode::Type arg3 ;
103155   Dali::SamplingMode::Type arg4 ;
103156   Dali::ImageDimensions *argp2 ;
103157   Dali::Devel::PixelBuffer result;
103158
103159   if (!jarg1) {
103160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103161     return 0;
103162   }
103163   std::string arg1_str(jarg1);
103164   arg1 = &arg1_str;
103165   argp2 = (Dali::ImageDimensions *)jarg2;
103166   if (!argp2) {
103167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103168     return 0;
103169   }
103170   arg2 = *argp2;
103171   arg3 = (Dali::FittingMode::Type)jarg3;
103172   arg4 = (Dali::SamplingMode::Type)jarg4;
103173   {
103174     try {
103175       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103176     } catch (std::out_of_range& e) {
103177       {
103178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103179       };
103180     } catch (std::exception& e) {
103181       {
103182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103183       };
103184     } catch (...) {
103185       {
103186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103187       };
103188     }
103189   }
103190   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103191
103192   return jresult;
103193 }
103194
103195
103196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103197   void * jresult ;
103198   std::string *arg1 = 0 ;
103199   Dali::ImageDimensions arg2 ;
103200   Dali::FittingMode::Type arg3 ;
103201   Dali::ImageDimensions *argp2 ;
103202   Dali::Devel::PixelBuffer result;
103203
103204   if (!jarg1) {
103205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103206     return 0;
103207   }
103208   std::string arg1_str(jarg1);
103209   arg1 = &arg1_str;
103210   argp2 = (Dali::ImageDimensions *)jarg2;
103211   if (!argp2) {
103212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103213     return 0;
103214   }
103215   arg2 = *argp2;
103216   arg3 = (Dali::FittingMode::Type)jarg3;
103217   {
103218     try {
103219       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103220     } catch (std::out_of_range& e) {
103221       {
103222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103223       };
103224     } catch (std::exception& e) {
103225       {
103226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103227       };
103228     } catch (...) {
103229       {
103230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103231       };
103232     }
103233   }
103234   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103235
103236   return jresult;
103237 }
103238
103239
103240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103241   void * jresult ;
103242   std::string *arg1 = 0 ;
103243   Dali::ImageDimensions arg2 ;
103244   Dali::ImageDimensions *argp2 ;
103245   Dali::Devel::PixelBuffer result;
103246
103247   if (!jarg1) {
103248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103249     return 0;
103250   }
103251   std::string arg1_str(jarg1);
103252   arg1 = &arg1_str;
103253   argp2 = (Dali::ImageDimensions *)jarg2;
103254   if (!argp2) {
103255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103256     return 0;
103257   }
103258   arg2 = *argp2;
103259   {
103260     try {
103261       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103262     } catch (std::out_of_range& e) {
103263       {
103264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103265       };
103266     } catch (std::exception& e) {
103267       {
103268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103269       };
103270     } catch (...) {
103271       {
103272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103273       };
103274     }
103275   }
103276   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103277
103278   return jresult;
103279 }
103280
103281
103282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103283   void * jresult ;
103284   std::string *arg1 = 0 ;
103285   Dali::Devel::PixelBuffer result;
103286
103287   if (!jarg1) {
103288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103289     return 0;
103290   }
103291   std::string arg1_str(jarg1);
103292   arg1 = &arg1_str;
103293   {
103294     try {
103295       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103296     } catch (std::out_of_range& e) {
103297       {
103298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103299       };
103300     } catch (std::exception& e) {
103301       {
103302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103303       };
103304     } catch (...) {
103305       {
103306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103307       };
103308     }
103309   }
103310   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103311
103312   return jresult;
103313 }
103314
103315
103316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
103317   void * jresult ;
103318   Dali::Toolkit::WebView result;
103319
103320   {
103321     try {
103322       result = Dali::Toolkit::WebView::New();
103323     } catch (std::out_of_range& e) {
103324       {
103325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103326       };
103327     } catch (std::exception& e) {
103328       {
103329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103330       };
103331     } catch (Dali::DaliException e) {
103332       {
103333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103334       };
103335     } catch (...) {
103336       {
103337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103338       };
103339     }
103340   }
103341   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103342   return jresult;
103343 }
103344
103345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
103346   void * jresult ;
103347   Dali::Toolkit::WebView result;
103348
103349   std::string *arg1;
103350   std::string *arg2;
103351
103352   if (!jarg1) {
103353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
103354     return 0;
103355   }
103356   if (!jarg2) {
103357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
103358     return 0;
103359   }
103360
103361   std::string jarg1_str = std::string(jarg1);
103362   std::string jarg2_str = std::string(jarg2);
103363
103364   arg1 = &jarg1_str;
103365   arg2 = &jarg2_str;
103366
103367   {
103368     try {
103369       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
103370     } catch (std::out_of_range& e) {
103371       {
103372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103373       };
103374     } catch (std::exception& e) {
103375       {
103376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103377       };
103378     } catch (Dali::DaliException e) {
103379       {
103380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103381       };
103382     } catch (...) {
103383       {
103384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103385       };
103386     }
103387   }
103388   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103389   return jresult;
103390 }
103391
103392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103393   void * jresult ;
103394   Dali::Toolkit::WebView *arg1 = 0 ;
103395   Dali::Toolkit::WebView *result = 0 ;
103396
103397   arg1 = (Dali::Toolkit::WebView *)jarg1;
103398   if (!arg1) {
103399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103400     return 0;
103401   }
103402   {
103403     try {
103404       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103405     } catch (std::out_of_range& e) {
103406       {
103407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103408       };
103409     } catch (std::exception& e) {
103410       {
103411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103412       };
103413     } catch (Dali::DaliException e) {
103414       {
103415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103416       };
103417     } catch (...) {
103418       {
103419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103420       };
103421     }
103422   }
103423   jresult = (void *)result;
103424   return jresult;
103425 }
103426
103427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103428   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103429   arg1 = (Dali::Toolkit::WebView *)jarg1;
103430   {
103431     try {
103432       delete arg1;
103433     } catch (std::out_of_range& e) {
103434       {
103435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103436       };
103437     } catch (std::exception& e) {
103438       {
103439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103440       };
103441     } catch (Dali::DaliException e) {
103442       {
103443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103444       };
103445     } catch (...) {
103446       {
103447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103448       };
103449     }
103450   }
103451 }
103452
103453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103454   void * jresult ;
103455   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103456   Dali::Toolkit::WebView *arg2 = 0 ;
103457   Dali::Toolkit::WebView *result = 0 ;
103458
103459   arg1 = (Dali::Toolkit::WebView *)jarg1;
103460   arg2 = (Dali::Toolkit::WebView *)jarg2;
103461   if (!arg2) {
103462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103463     return 0;
103464   }
103465   {
103466     try {
103467       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103468     } catch (std::out_of_range& e) {
103469       {
103470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103471       };
103472     } catch (std::exception& e) {
103473       {
103474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103475       };
103476     } catch (Dali::DaliException e) {
103477       {
103478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103479       };
103480     } catch (...) {
103481       {
103482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103483       };
103484     }
103485   }
103486   jresult = (void *)result;
103487   return jresult;
103488 }
103489
103490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103491   void * jresult ;
103492   Dali::BaseHandle arg1 ;
103493   Dali::BaseHandle *argp1 ;
103494   Dali::Toolkit::WebView result;
103495
103496   argp1 = (Dali::BaseHandle *)jarg1;
103497   if (!argp1) {
103498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103499     return 0;
103500   }
103501   arg1 = *argp1;
103502   {
103503     try {
103504       result = Dali::Toolkit::WebView::DownCast(arg1);
103505     } catch (std::out_of_range& e) {
103506       {
103507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103508       };
103509     } catch (std::exception& e) {
103510       {
103511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103512       };
103513     } catch (Dali::DaliException e) {
103514       {
103515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103516       };
103517     } catch (...) {
103518       {
103519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103520       };
103521     }
103522   }
103523   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103524   return jresult;
103525 }
103526
103527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103528   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103529   std::string *arg2;
103530
103531   arg1 = (Dali::Toolkit::WebView *)jarg1;
103532
103533   if (!jarg2) {
103534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103535     return;
103536   }
103537
103538   std::string jarg2str = std::string(jarg2);
103539   arg2 = &jarg2str;
103540   {
103541     try {
103542       (arg1)->LoadUrl((std::string const &)*arg2);
103543     } catch (std::out_of_range& e) {
103544       {
103545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103546       };
103547     } catch (std::exception& e) {
103548       {
103549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103550       };
103551     } catch (Dali::DaliException e) {
103552       {
103553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103554       };
103555     } catch (...) {
103556       {
103557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103558       };
103559     }
103560   }
103561 }
103562
103563 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103564   char * jresult ;
103565   std::string result;
103566
103567   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103568
103569   arg1 = (Dali::Toolkit::WebView *)jarg1;
103570   {
103571     try {
103572       result = arg1->GetUrl();
103573     } catch (std::out_of_range& e) {
103574       {
103575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103576       };
103577     } catch (std::exception& e) {
103578       {
103579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103580       };
103581     } catch (Dali::DaliException e) {
103582       {
103583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103584       };
103585     } catch (...) {
103586       {
103587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103588       };
103589     }
103590   }
103591
103592   jresult = SWIG_csharp_string_callback((&result)->c_str());
103593   return jresult;
103594 }
103595
103596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103597   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103598   std::string *arg2;
103599
103600   arg1 = (Dali::Toolkit::WebView *)jarg1;
103601   if (!jarg2) {
103602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103603     return;
103604   }
103605   std::string jarg2str = std::string(jarg2);
103606   arg2 = &jarg2str;
103607   {
103608     try {
103609       (arg1)->LoadHTMLString((std::string const &)*arg2);
103610     } catch (std::out_of_range& e) {
103611       {
103612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103613       };
103614     } catch (std::exception& e) {
103615       {
103616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103617       };
103618     } catch (Dali::DaliException e) {
103619       {
103620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103621       };
103622     } catch (...) {
103623       {
103624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103625       };
103626     }
103627   }
103628 }
103629
103630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103631   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103632
103633   arg1 = (Dali::Toolkit::WebView *)jarg1;
103634   {
103635     try {
103636       (arg1)->Reload();
103637     } catch (std::out_of_range& e) {
103638       {
103639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103640       };
103641     } catch (std::exception& e) {
103642       {
103643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103644       };
103645     } catch (Dali::DaliException e) {
103646       {
103647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103648       };
103649     } catch (...) {
103650       {
103651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103652       };
103653     }
103654   }
103655 }
103656
103657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103658   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103659
103660   arg1 = (Dali::Toolkit::WebView *)jarg1;
103661   {
103662     try {
103663       (arg1)->StopLoading();
103664     } catch (std::out_of_range& e) {
103665       {
103666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103667       };
103668     } catch (std::exception& e) {
103669       {
103670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103671       };
103672     } catch (Dali::DaliException e) {
103673       {
103674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103675       };
103676     } catch (...) {
103677       {
103678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103679       };
103680     }
103681   }
103682 }
103683
103684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103685   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103686
103687   arg1 = (Dali::Toolkit::WebView *)jarg1;
103688   {
103689     try {
103690       (arg1)->GoBack();
103691     } catch (std::out_of_range& e) {
103692       {
103693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103694       };
103695     } catch (std::exception& e) {
103696       {
103697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103698       };
103699     } catch (Dali::DaliException e) {
103700       {
103701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103702       };
103703     } catch (...) {
103704       {
103705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103706       };
103707     }
103708   }
103709 }
103710
103711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103712   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103713
103714   arg1 = (Dali::Toolkit::WebView *)jarg1;
103715   {
103716     try {
103717       (arg1)->GoForward();
103718     } catch (std::out_of_range& e) {
103719       {
103720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103721       };
103722     } catch (std::exception& e) {
103723       {
103724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103725       };
103726     } catch (Dali::DaliException e) {
103727       {
103728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103729       };
103730     } catch (...) {
103731       {
103732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103733       };
103734     }
103735   }
103736 }
103737
103738 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103739   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103740   bool ret;
103741
103742   arg1 = (Dali::Toolkit::WebView *)jarg1;
103743   {
103744     try {
103745       ret = (arg1)->CanGoBack();
103746     } catch (std::out_of_range& e) {
103747       {
103748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103749       };
103750     } catch (std::exception& e) {
103751       {
103752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103753       };
103754     } catch (Dali::DaliException e) {
103755       {
103756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103757       };
103758     } catch (...) {
103759       {
103760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103761       };
103762     }
103763   }
103764   return ret;
103765 }
103766
103767 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103768   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103769   bool ret;
103770
103771   arg1 = (Dali::Toolkit::WebView *)jarg1;
103772   {
103773     try {
103774       ret = (arg1)->CanGoForward();
103775     } catch (std::out_of_range& e) {
103776       {
103777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103778       };
103779     } catch (std::exception& e) {
103780       {
103781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103782       };
103783     } catch (Dali::DaliException e) {
103784       {
103785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103786       };
103787     } catch (...) {
103788       {
103789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103790       };
103791     }
103792   }
103793   return ret;
103794 }
103795
103796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
103797   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103798   std::string *arg2;
103799
103800   arg1 = (Dali::Toolkit::WebView *)jarg1;
103801   if (!jarg2) {
103802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103803     return;
103804   }
103805   std::string jarg2_str = std::string(jarg2);
103806   arg2 = &jarg2_str;
103807   {
103808     try {
103809       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103810     } catch (std::out_of_range& e) {
103811       {
103812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103813       };
103814     } catch (std::exception& e) {
103815       {
103816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103817       };
103818     } catch (Dali::DaliException e) {
103819       {
103820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103821       };
103822     } catch (...) {
103823       {
103824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103825       };
103826     }
103827   }
103828 }
103829
103830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103831 {
103832   if (!jarg2) {
103833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103834     return;
103835   }
103836
103837   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103838   std::string exposedObjectName = jarg2;
103839   void (*handler)(char*) = (void (*)(char*)) jarg3;
103840
103841   {
103842     try {
103843       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103844         handler(SWIG_csharp_string_callback(message.c_str()));
103845       });
103846     } catch (std::out_of_range& e) {
103847       {
103848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103849       };
103850     } catch (std::exception& e) {
103851       {
103852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103853       };
103854     } catch (Dali::DaliException e) {
103855       {
103856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103857       };
103858     } catch (...) {
103859       {
103860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103861       };
103862     }
103863   }
103864 }
103865
103866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103867   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103868
103869   arg1 = (Dali::Toolkit::WebView *)jarg1;
103870   {
103871     try {
103872       (arg1)->ClearHistory();
103873     } catch (std::out_of_range& e) {
103874       {
103875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103876       };
103877     } catch (std::exception& e) {
103878       {
103879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103880       };
103881     } catch (Dali::DaliException e) {
103882       {
103883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103884       };
103885     } catch (...) {
103886       {
103887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103888       };
103889     }
103890   }
103891 }
103892
103893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103894   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103895
103896   arg1 = (Dali::Toolkit::WebView *)jarg1;
103897   {
103898     try {
103899       (arg1)->ClearCache();
103900     } catch (std::out_of_range& e) {
103901       {
103902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103903       };
103904     } catch (std::exception& e) {
103905       {
103906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103907       };
103908     } catch (Dali::DaliException e) {
103909       {
103910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103911       };
103912     } catch (...) {
103913       {
103914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103915       };
103916     }
103917   }
103918 }
103919
103920 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103921     return (Dali::Toolkit::Control *)jarg1;
103922 }
103923
103924
103925 // Proxy class of WebViewSignal.
103926 // WebViewSignal has an argument of std::string type which is not supported at C# side.
103927 // The purpose of this class is to convert signal argument of string type safely.
103928 class WebViewSignalProxy : public ConnectionTracker
103929 {
103930 public:
103931   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
103932   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
103933   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
103934
103935   WebViewSignalProxy(OriginalSignalType* signal)
103936     : mSignalPtr(signal)
103937   {
103938   }
103939
103940   void Connect(CallbackType csharpCallback)
103941   {
103942     if (mSignalPtr->Empty())
103943     {
103944       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
103945     }
103946     mProxySignal.Connect(csharpCallback);
103947   }
103948
103949   void Disconnect(CallbackType csharpCallback)
103950   {
103951     mProxySignal.Disconnect(csharpCallback);
103952     if (mProxySignal.Empty())
103953     {
103954       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
103955     }
103956   }
103957
103958   bool Empty()
103959   {
103960     return mProxySignal.Empty();
103961   }
103962
103963   std::size_t GetConnectionCount()
103964   {
103965     return mProxySignal.GetConnectionCount();
103966   }
103967
103968   void Emit(Dali::Toolkit::WebView& webview, char* url)
103969   {
103970     if (!mProxySignal.Empty())
103971     {
103972       mProxySignal.Emit(webview, url);
103973     }
103974   }
103975
103976   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
103977   {
103978     // Safe string conversion
103979     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
103980   }
103981
103982 private:
103983   OriginalSignalType* mSignalPtr;
103984   ProxySignalType mProxySignal;
103985 };
103986
103987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
103988   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103989   WebViewSignalProxy* result = NULL;
103990   {
103991     try {
103992       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
103993     } catch (std::out_of_range& e) {
103994       {
103995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103996       };
103997     } catch (std::exception& e) {
103998       {
103999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104000       };
104001     } catch (Dali::DaliException e) {
104002       {
104003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104004       };
104005     } catch (...) {
104006       {
104007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104008       };
104009     }
104010   }
104011   return (void*) result;
104012 }
104013
104014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
104015   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104016   WebViewSignalProxy* result = NULL;
104017   {
104018     try {
104019       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
104020     } catch (std::out_of_range& e) {
104021       {
104022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104023       };
104024     } catch (std::exception& e) {
104025       {
104026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104027       };
104028     } catch (Dali::DaliException e) {
104029       {
104030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104031       };
104032     } catch (...) {
104033       {
104034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104035       };
104036     }
104037   }
104038   return (void*) result;
104039 }
104040
104041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
104042 {
104043   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
104044   {
104045     try {
104046       delete object;
104047     } catch (std::out_of_range& e) {
104048       {
104049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104050       };
104051     } catch (std::exception& e) {
104052       {
104053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104054       };
104055     } catch (Dali::DaliException e) {
104056       {
104057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104058       };
104059     } catch (...) {
104060       {
104061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104062       };
104063     }
104064   }
104065 }
104066
104067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
104068 {
104069   bool result;
104070   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104071   {
104072     try {
104073       result = (bool)proxy->Empty();
104074     } catch (std::out_of_range& e) {
104075       {
104076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104077       };
104078     } catch (std::exception& e) {
104079       {
104080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104081       };
104082     } catch (Dali::DaliException e) {
104083       {
104084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104085       };
104086     } catch (...) {
104087       {
104088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104089       };
104090     }
104091   }
104092   return (unsigned int) result;
104093 }
104094
104095
104096 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
104097 {
104098   std::size_t result;
104099   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
104100   {
104101     try {
104102       result = arg1->GetConnectionCount();
104103     } catch (std::out_of_range& e) {
104104       {
104105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104106       };
104107     } catch (std::exception& e) {
104108       {
104109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104110       };
104111     } catch (Dali::DaliException e) {
104112       {
104113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104114       };
104115     } catch (...) {
104116       {
104117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104118       };
104119     }
104120   }
104121   return (unsigned long) result;
104122 }
104123
104124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
104125 {
104126   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104127   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104128   {
104129     try {
104130       proxy->Connect(callback);
104131     } catch (std::out_of_range& e) {
104132       {
104133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104134       };
104135     } catch (std::exception& e) {
104136       {
104137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104138       };
104139     } catch (Dali::DaliException e) {
104140       {
104141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104142       };
104143     } catch (...) {
104144       {
104145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104146       };
104147     }
104148   }
104149 }
104150
104151
104152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
104153   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104154   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104155   {
104156     try {
104157       proxy->Disconnect(callback);
104158     } catch (std::out_of_range& e) {
104159       {
104160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104161       };
104162     } catch (std::exception& e) {
104163       {
104164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104165       };
104166     } catch (Dali::DaliException e) {
104167       {
104168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104169       };
104170     } catch (...) {
104171       {
104172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104173       };
104174     }
104175   }
104176 }
104177
104178
104179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
104180   if (!jarg2) {
104181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
104182     return ;
104183   }
104184   if (!jarg3) {
104185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
104186     return ;
104187   }
104188
104189   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104190   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
104191   {
104192     try {
104193       proxy->Emit(*webview, jarg3);
104194     } catch (std::out_of_range& e) {
104195       {
104196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104197       };
104198     } catch (std::exception& e) {
104199       {
104200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104201       };
104202     } catch (Dali::DaliException e) {
104203       {
104204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104205       };
104206     } catch (...) {
104207       {
104208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104209       };
104210     }
104211   }
104212 }
104213
104214 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
104215   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
104216   char * jresult = SWIG_csharp_string_callback((const char *)result);
104217   return jresult;
104218 }
104219
104220 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
104221   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
104222   return result;
104223 }
104224
104225 #ifdef __cplusplus
104226 }
104227 #endif
104228