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/application-extensions.h>
 440 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 441
 442 #include <dali/devel-api/images/nine-patch-image.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457
 458 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 459 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 460 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 461
 462 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 464 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 465
 466 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 467 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477
 478
 479 // add here SWIG version check
 480
 481 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 482 // disable Swig-dependent warnings
 483
 484 // 'identifier1' has C-linkage specified,
 485 // but returns UDT 'identifier2' which is incompatible with C
 486 #pragma warning(disable: 4190)
 487
 488 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 489 #pragma warning(disable: 4800)
 490
 491 // debug info too long etc etc
 492 #pragma warning(disable: 4786)
 493 #endif
 494
 495
 496 #include <stdexcept>
 497
 498
 499 #include <string>
 500
 501
 502 #include <vector>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <map>
 508 #include <algorithm>
 509 #include <stdexcept>
 510
 511
 512 #include <utility>
 513
 514
 515 typedef float floatp;
 516
 517 SWIGINTERN floatp *new_floatp(){
 518   return new float();
 519 }
 520 SWIGINTERN void delete_floatp(floatp *self){
 521   if (self) delete self;
 522 }
 523 SWIGINTERN void floatp_assign(floatp *self,float value){
 524   *self = value;
 525 }
 526 SWIGINTERN float floatp_value(floatp *self){
 527   return *self;
 528 }
 529 SWIGINTERN float *floatp_cast(floatp *self){
 530   return self;
 531 }
 532 SWIGINTERN floatp *floatp_frompointer(float *t){
 533   return (floatp *) t;
 534 }
 535
 536 typedef int intp;
 537
 538 SWIGINTERN intp *new_intp(){
 539   return new int();
 540 }
 541 SWIGINTERN void delete_intp(intp *self){
 542   if (self) delete self;
 543 }
 544 SWIGINTERN void intp_assign(intp *self,int value){
 545   *self = value;
 546 }
 547 SWIGINTERN int intp_value(intp *self){
 548   return *self;
 549 }
 550 SWIGINTERN int *intp_cast(intp *self){
 551   return self;
 552 }
 553 SWIGINTERN intp *intp_frompointer(int *t){
 554   return (intp *) t;
 555 }
 556
 557 typedef double doublep;
 558
 559 SWIGINTERN doublep *new_doublep(){
 560   return new double();
 561 }
 562 SWIGINTERN void delete_doublep(doublep *self){
 563   if (self) delete self;
 564 }
 565 SWIGINTERN void doublep_assign(doublep *self,double value){
 566   *self = value;
 567 }
 568 SWIGINTERN double doublep_value(doublep *self){
 569   return *self;
 570 }
 571 SWIGINTERN double *doublep_cast(doublep *self){
 572   return self;
 573 }
 574 SWIGINTERN doublep *doublep_frompointer(double *t){
 575   return (doublep *) t;
 576 }
 577
 578 typedef unsigned int uintp;
 579
 580 SWIGINTERN uintp *new_uintp(){
 581   return new unsigned int();
 582 }
 583 SWIGINTERN void delete_uintp(uintp *self){
 584   if (self) delete self;
 585 }
 586 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 587   *self = value;
 588 }
 589 SWIGINTERN unsigned int uintp_value(uintp *self){
 590   return *self;
 591 }
 592 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 593   return self;
 594 }
 595 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 596   return (uintp *) t;
 597 }
 598
 599 typedef unsigned short ushortp;
 600
 601 SWIGINTERN ushortp *new_ushortp(){
 602   return new unsigned short();
 603 }
 604 SWIGINTERN void delete_ushortp(ushortp *self){
 605   if (self) delete self;
 606 }
 607 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 608   *self = value;
 609 }
 610 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 611   return *self;
 612 }
 613 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 614   return self;
 615 }
 616 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 617   return (ushortp *) t;
 618 }
 619
 620 unsigned int int_to_uint(int x) {
 621    return (unsigned int) x;
 622 }
 623
 624
 625 using namespace Dali;
 626 using namespace Dali::Toolkit;
 627
 628 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 629 {
 630   bool result = false;
 631   try
 632   {
 633     // C++ code. DALi uses Handle <-> Body design pattern.
 634     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 635     // Handles in DALi can be converted into a boolean type
 636     // to check if the handle has a valid body attached to it.
 637     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 638     if( *self )
 639     {
 640       result = true;
 641     }
 642     else
 643     {
 644       result = false;
 645     }
 646   }
 647   catch (std::out_of_range& e)
 648   {
 649     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 650     return 0;
 651   }
 652   catch (std::exception& e)
 653   {
 654     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 655     return 0;
 656   }
 657   catch (DaliException e)
 658   {
 659     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 660     return 0;
 661   }
 662   catch (...)
 663   {
 664     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 665     return 0;
 666   }
 667   return result;
 668 }
 669
 670 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 671 {
 672   bool result = false;
 673   try
 674   {
 675     // C++ code. Check if two handles reference the same implemtion
 676     if( *self == rhs)
 677     {
 678       result = true;
 679     }
 680     else
 681     {
 682       result = false;
 683     }
 684   }
 685   catch (std::out_of_range& e)
 686   {
 687     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 688     return 0;
 689   }
 690   catch (std::exception& e)
 691   {
 692     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 693     return 0;
 694   }
 695   catch (DaliException e)
 696   {
 697     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 698     return 0;
 699   }
 700   catch (...)
 701   {
 702     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 703     return 0;
 704   }
 705   return result;
 706 }
 707
 708
 709 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 710      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 711    }
 712 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){
 713      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 714    }
 715 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 716         std::vector< Dali::TouchPoint >* pv = 0;
 717         if (capacity >= 0) {
 718           pv = new std::vector< Dali::TouchPoint >();
 719           pv->reserve(capacity);
 720        } else {
 721           throw std::out_of_range("capacity");
 722        }
 723        return pv;
 724       }
 725 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 726         if (index>=0 && index<(int)self->size())
 727           return (*self)[index];
 728         else
 729           throw std::out_of_range("index");
 730       }
 731 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 732         if (index>=0 && index<(int)self->size())
 733           return (*self)[index];
 734         else
 735           throw std::out_of_range("index");
 736       }
 737 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 738         if (index>=0 && index<(int)self->size())
 739           (*self)[index] = val;
 740         else
 741           throw std::out_of_range("index");
 742       }
 743 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 744         self->insert(self->end(), values.begin(), values.end());
 745       }
 746 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 747         if (index < 0)
 748           throw std::out_of_range("index");
 749         if (count < 0)
 750           throw std::out_of_range("count");
 751         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 752           throw std::invalid_argument("invalid range");
 753         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 754       }
 755 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 756         if (index>=0 && index<(int)self->size()+1)
 757           self->insert(self->begin()+index, x);
 758         else
 759           throw std::out_of_range("index");
 760       }
 761 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 762         if (index>=0 && index<(int)self->size()+1)
 763           self->insert(self->begin()+index, values.begin(), values.end());
 764         else
 765           throw std::out_of_range("index");
 766       }
 767 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 768         if (index>=0 && index<(int)self->size())
 769           self->erase(self->begin() + index);
 770         else
 771           throw std::out_of_range("index");
 772       }
 773 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 774         if (index < 0)
 775           throw std::out_of_range("index");
 776         if (count < 0)
 777           throw std::out_of_range("count");
 778         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 779           throw std::invalid_argument("invalid range");
 780         self->erase(self->begin()+index, self->begin()+index+count);
 781       }
 782 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 783         if (count < 0)
 784           throw std::out_of_range("count");
 785         return new std::vector< Dali::TouchPoint >(count, value);
 786       }
 787 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 788         std::reverse(self->begin(), self->end());
 789       }
 790 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 791         if (index < 0)
 792           throw std::out_of_range("index");
 793         if (count < 0)
 794           throw std::out_of_range("count");
 795         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 796           throw std::invalid_argument("invalid range");
 797         std::reverse(self->begin()+index, self->begin()+index+count);
 798       }
 799 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 800         if (index < 0)
 801           throw std::out_of_range("index");
 802         if (index+values.size() > self->size())
 803           throw std::out_of_range("index");
 804         std::copy(values.begin(), values.end(), self->begin()+index);
 805       }
 806 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 807          return self->Empty();
 808       }
 809 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 810         return self->GetConnectionCount();
 811       }
 812 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 813           self->Connect( func );
 814       }
 815 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 816           self->Disconnect( func );
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 819           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 820 /*@SWIG@*/ self->Emit( arg );
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 829           self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 832           self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 835           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 839          return self->Empty();
 840       }
 841 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){
 842         return self->GetConnectionCount();
 843       }
 844 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 *)){
 845           self->Connect( func );
 846       }
 847 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 *)){
 848           self->Disconnect( func );
 849       }
 850 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){
 851           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 852 /*@SWIG@*/ self->Emit( arg );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 855          return self->Empty();
 856       }
 857 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 858         return self->GetConnectionCount();
 859       }
 860 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 861           self->Connect( func );
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 864           self->Disconnect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 867           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 868 /*@SWIG@*/ self->Emit( arg );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 871          return self->Empty();
 872       }
 873 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 874         return self->GetConnectionCount();
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 877           self->Connect( func );
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 880           self->Disconnect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 883           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 884 /*@SWIG@*/ self->Emit( arg );
 885       }
 886 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){
 887          return self->Empty();
 888       }
 889 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){
 890         return self->GetConnectionCount();
 891       }
 892 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 &)){
 893         self->Connect( func );
 894       }
 895 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 &)){
 896         self->Disconnect( func );
 897       }
 898 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){
 899         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg1, arg2 );
 901       }
 902 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){
 903          return self->Empty();
 904       }
 905 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){
 906         return self->GetConnectionCount();
 907       }
 908 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 &)){
 909         self->Connect( func );
 910       }
 911 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 &)){
 912         self->Disconnect( func );
 913       }
 914 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){
 915         return self->Emit( arg1, arg2 );
 916       }
 917 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){
 918          return self->Empty();
 919       }
 920 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){
 921         return self->GetConnectionCount();
 922       }
 923 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 &)){
 924         self->Connect( func );
 925       }
 926 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 &)){
 927         self->Disconnect( func );
 928       }
 929 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){
 930         return self->Emit( arg1, arg2 );
 931       }
 932 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){
 933          return self->Empty();
 934       }
 935 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){
 936         return self->GetConnectionCount();
 937       }
 938 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 &)){
 939         self->Connect( func );
 940       }
 941 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 &)){
 942         self->Disconnect( func );
 943       }
 944 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){
 945         return self->Emit( arg1, arg2 );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 954           self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 960           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 964          return self->Empty();
 965       }
 966 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){
 967         return self->GetConnectionCount();
 968       }
 969 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 &)){
 970           self->Connect( func );
 971       }
 972 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 &)){
 973           self->Disconnect( func );
 974       }
 975 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){
 976           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 980          return self->Empty();
 981       }
 982 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){
 983         return self->GetConnectionCount();
 984       }
 985 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 &)){
 986           self->Connect( func );
 987       }
 988 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 &)){
 989           self->Disconnect( func );
 990       }
 991 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){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 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){
 999         return self->GetConnectionCount();
1000       }
1001 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 &)){
1002           self->Connect( func );
1003       }
1004 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 &)){
1005           self->Disconnect( func );
1006       }
1007 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){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 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){
1012          return self->Empty();
1013       }
1014 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){
1015         return self->GetConnectionCount();
1016       }
1017 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 &)){
1018         self->Connect( func );
1019       }
1020 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 &)){
1021         self->Disconnect( func );
1022       }
1023 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){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 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){
1028          return self->Empty();
1029       }
1030 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){
1031         return self->GetConnectionCount();
1032       }
1033 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 &)){
1034         self->Connect( func );
1035       }
1036 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 &)){
1037         self->Disconnect( func );
1038       }
1039 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){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 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){
1044          return self->Empty();
1045       }
1046 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){
1047         return self->GetConnectionCount();
1048       }
1049 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 &)){
1050         self->Connect( func );
1051       }
1052 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 &)){
1053         self->Disconnect( func );
1054       }
1055 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){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1060          return self->Empty();
1061       }
1062 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1063         return self->GetConnectionCount();
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1066           self->Connect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1069           self->Disconnect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1072           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1073 /*@SWIG@*/ self->Emit( arg );
1074       }
1075 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){
1076          return self->Empty();
1077       }
1078 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){
1079         return self->GetConnectionCount();
1080       }
1081 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)){
1082           return self->Connect( func );
1083       }
1084 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)){
1085           self->Disconnect( func );
1086       }
1087 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){
1088           self->Emit( arg1, arg3 );
1089       }
1090 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){
1091          return self->Empty();
1092       }
1093 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){
1094         return self->GetConnectionCount();
1095       }
1096 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)){
1097           return self->Connect( func );
1098       }
1099 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)){
1100           self->Disconnect( func );
1101       }
1102 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){
1103           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1104 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1105       }
1106
1107 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1108          return self->Empty();
1109       }
1110 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1111         return self->GetConnectionCount();
1112       }
1113 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1114           self->Connect( func );
1115       }
1116 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1117           self->Disconnect( func );
1118       }
1119 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1120           return self->Emit();
1121       }
1122
1123 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1124         std::vector< unsigned int >* pv = 0;
1125         if (capacity >= 0) {
1126           pv = new std::vector< unsigned int >();
1127           pv->reserve(capacity);
1128        } else {
1129           throw std::out_of_range("capacity");
1130        }
1131        return pv;
1132       }
1133 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1134         if (index>=0 && index<(int)self->size())
1135           return (*self)[index];
1136         else
1137           throw std::out_of_range("index");
1138       }
1139 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1140         if (index>=0 && index<(int)self->size())
1141           return (*self)[index];
1142         else
1143           throw std::out_of_range("index");
1144       }
1145 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1146         if (index>=0 && index<(int)self->size())
1147           (*self)[index] = val;
1148         else
1149           throw std::out_of_range("index");
1150       }
1151 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1152         self->insert(self->end(), values.begin(), values.end());
1153       }
1154 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1164         if (index>=0 && index<(int)self->size()+1)
1165           self->insert(self->begin()+index, x);
1166         else
1167           throw std::out_of_range("index");
1168       }
1169 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1170         if (index>=0 && index<(int)self->size()+1)
1171           self->insert(self->begin()+index, values.begin(), values.end());
1172         else
1173           throw std::out_of_range("index");
1174       }
1175 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1176         if (index>=0 && index<(int)self->size())
1177           self->erase(self->begin() + index);
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1182         if (index < 0)
1183           throw std::out_of_range("index");
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1187           throw std::invalid_argument("invalid range");
1188         self->erase(self->begin()+index, self->begin()+index+count);
1189       }
1190 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1191         if (count < 0)
1192           throw std::out_of_range("count");
1193         return new std::vector< unsigned int >(count, value);
1194       }
1195 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1196         std::reverse(self->begin(), self->end());
1197       }
1198 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1199         if (index < 0)
1200           throw std::out_of_range("index");
1201         if (count < 0)
1202           throw std::out_of_range("count");
1203         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1204           throw std::invalid_argument("invalid range");
1205         std::reverse(self->begin()+index, self->begin()+index+count);
1206       }
1207 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1208         if (index < 0)
1209           throw std::out_of_range("index");
1210         if (index+values.size() > self->size())
1211           throw std::out_of_range("index");
1212         std::copy(values.begin(), values.end(), self->begin()+index);
1213       }
1214 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1215         return std::find(self->begin(), self->end(), value) != self->end();
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1220         if (it != self->end())
1221           index = (int)(it - self->begin());
1222         return index;
1223       }
1224 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1225         int index = -1;
1226         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1227         if (rit != self->rend())
1228           index = (int)(self->rend() - 1 - rit);
1229         return index;
1230       }
1231 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1232         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1233         if (it != self->end()) {
1234           self->erase(it);
1235           return true;
1236         }
1237         return false;
1238       }
1239 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){
1240         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1241         if (capacity >= 0) {
1242           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1243           pv->reserve(capacity);
1244        } else {
1245           throw std::out_of_range("capacity");
1246        }
1247        return pv;
1248       }
1249 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){
1250         if (index>=0 && index<(int)self->size())
1251           return (*self)[index];
1252         else
1253           throw std::out_of_range("index");
1254       }
1255 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){
1256         if (index>=0 && index<(int)self->size())
1257           return (*self)[index];
1258         else
1259           throw std::out_of_range("index");
1260       }
1261 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){
1262         if (index>=0 && index<(int)self->size())
1263           (*self)[index] = val;
1264         else
1265           throw std::out_of_range("index");
1266       }
1267 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){
1268         self->insert(self->end(), values.begin(), values.end());
1269       }
1270 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){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1278       }
1279 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){
1280         if (index>=0 && index<(int)self->size()+1)
1281           self->insert(self->begin()+index, x);
1282         else
1283           throw std::out_of_range("index");
1284       }
1285 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){
1286         if (index>=0 && index<(int)self->size()+1)
1287           self->insert(self->begin()+index, values.begin(), values.end());
1288         else
1289           throw std::out_of_range("index");
1290       }
1291 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){
1292         if (index>=0 && index<(int)self->size())
1293           self->erase(self->begin() + index);
1294         else
1295           throw std::out_of_range("index");
1296       }
1297 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){
1298         if (index < 0)
1299           throw std::out_of_range("index");
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1303           throw std::invalid_argument("invalid range");
1304         self->erase(self->begin()+index, self->begin()+index+count);
1305       }
1306 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){
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1310       }
1311 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){
1312         std::reverse(self->begin(), self->end());
1313       }
1314 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){
1315         if (index < 0)
1316           throw std::out_of_range("index");
1317         if (count < 0)
1318           throw std::out_of_range("count");
1319         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1320           throw std::invalid_argument("invalid range");
1321         std::reverse(self->begin()+index, self->begin()+index+count);
1322       }
1323 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){
1324         if (index < 0)
1325           throw std::out_of_range("index");
1326         if (index+values.size() > self->size())
1327           throw std::out_of_range("index");
1328         std::copy(values.begin(), values.end(), self->begin()+index);
1329       }
1330 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1331         std::vector< Dali::Actor >* pv = 0;
1332         if (capacity >= 0) {
1333           pv = new std::vector< Dali::Actor >();
1334           pv->reserve(capacity);
1335        } else {
1336           throw std::out_of_range("capacity");
1337        }
1338        return pv;
1339       }
1340 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1341         if (index>=0 && index<(int)self->size())
1342           return (*self)[index];
1343         else
1344           throw std::out_of_range("index");
1345       }
1346 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1347         if (index>=0 && index<(int)self->size())
1348           return (*self)[index];
1349         else
1350           throw std::out_of_range("index");
1351       }
1352 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1353         if (index>=0 && index<(int)self->size())
1354           (*self)[index] = val;
1355         else
1356           throw std::out_of_range("index");
1357       }
1358 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1359         self->insert(self->end(), values.begin(), values.end());
1360       }
1361 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1371         if (index>=0 && index<(int)self->size()+1)
1372           self->insert(self->begin()+index, x);
1373         else
1374           throw std::out_of_range("index");
1375       }
1376 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1377         if (index>=0 && index<(int)self->size()+1)
1378           self->insert(self->begin()+index, values.begin(), values.end());
1379         else
1380           throw std::out_of_range("index");
1381       }
1382 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1383         if (index>=0 && index<(int)self->size())
1384           self->erase(self->begin() + index);
1385         else
1386           throw std::out_of_range("index");
1387       }
1388 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1389         if (index < 0)
1390           throw std::out_of_range("index");
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1394           throw std::invalid_argument("invalid range");
1395         self->erase(self->begin()+index, self->begin()+index+count);
1396       }
1397 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1398         if (count < 0)
1399           throw std::out_of_range("count");
1400         return new std::vector< Dali::Actor >(count, value);
1401       }
1402 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1403         std::reverse(self->begin(), self->end());
1404       }
1405 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1406         if (index < 0)
1407           throw std::out_of_range("index");
1408         if (count < 0)
1409           throw std::out_of_range("count");
1410         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1411           throw std::invalid_argument("invalid range");
1412         std::reverse(self->begin()+index, self->begin()+index+count);
1413       }
1414 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1415         if (index < 0)
1416           throw std::out_of_range("index");
1417         if (index+values.size() > self->size())
1418           throw std::out_of_range("index");
1419         std::copy(values.begin(), values.end(), self->begin()+index);
1420       }
1421 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1422          return self->Empty();
1423       }
1424 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1425         return self->GetConnectionCount();
1426       }
1427 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 &)){
1428           self->Connect( func );
1429       }
1430 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 &)){
1431           self->Disconnect( func );
1432       }
1433 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){
1434           return self->Emit( arg );
1435       }
1436 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){
1437          return self->Empty();
1438       }
1439 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){
1440         return self->GetConnectionCount();
1441       }
1442 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)){
1443         self->Connect( func );
1444       }
1445 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)){
1446         self->Disconnect( func );
1447       }
1448 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){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1453          return self->Empty();
1454       }
1455 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){
1456         return self->GetConnectionCount();
1457       }
1458 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)){
1459         self->Connect( func );
1460       }
1461 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)){
1462         self->Disconnect( func );
1463       }
1464 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){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 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)){
1475         self->Connect( func );
1476       }
1477 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)){
1478         self->Disconnect( func );
1479       }
1480 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){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 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){
1485          return self->Empty();
1486       }
1487 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){
1488         return self->GetConnectionCount();
1489       }
1490 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)){
1491         self->Connect( func );
1492       }
1493 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)){
1494         self->Disconnect( func );
1495       }
1496 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){
1497         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1498 /*@SWIG@*/ self->Emit( arg1, arg2 );
1499       }
1500 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1501          return self->Empty();
1502       }
1503 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1504         return self->GetConnectionCount();
1505       }
1506 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)){
1507           self->Connect( func );
1508       }
1509 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)){
1510           self->Disconnect( func );
1511       }
1512 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1513           return self->Emit( arg );
1514       }
1515 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1516          return self->Empty();
1517       }
1518 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1519         return self->GetConnectionCount();
1520       }
1521 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)){
1522           self->Connect( func );
1523       }
1524 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)){
1525           self->Disconnect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg );
1530       }
1531 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){
1532          return self->Empty();
1533       }
1534 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){
1535         return self->GetConnectionCount();
1536       }
1537 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)){
1538           return self->Connect( func );
1539       }
1540 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)){
1541           self->Disconnect( func );
1542       }
1543 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){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1546       }
1547 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1548          return self->Empty();
1549       }
1550 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1551         return self->GetConnectionCount();
1552       }
1553 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)){
1554           self->Connect( func );
1555       }
1556 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)){
1557           self->Disconnect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg );
1562       }
1563 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){
1564          return self->Empty();
1565       }
1566 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){
1567         return self->GetConnectionCount();
1568       }
1569 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)){
1570           return self->Connect( func );
1571       }
1572 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)){
1573           self->Disconnect( func );
1574       }
1575 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){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1578       }
1579 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){
1580          return self->Empty();
1581       }
1582 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){
1583         return self->GetConnectionCount();
1584       }
1585 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 &)){
1586           self->Connect( func );
1587       }
1588 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 &)){
1589           self->Disconnect( func );
1590       }
1591 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){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1596          return self->Empty();
1597       }
1598 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){
1599         return self->GetConnectionCount();
1600       }
1601 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 &)){
1602           self->Connect( func );
1603       }
1604 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 &)){
1605           self->Disconnect( func );
1606       }
1607 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){
1608           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1609 /*@SWIG@*/ self->Emit( arg );
1610       }
1611
1612
1613 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){
1614          return self->Empty();
1615       }
1616 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){
1617         return self->GetConnectionCount();
1618       }
1619 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 &)){
1620         self->Connect( func );
1621       }
1622 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 &)){
1623         self->Disconnect( func );
1624       }
1625 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){
1626         return self->Emit( arg1, arg2 );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 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)){
1635           self->Connect( func );
1636       }
1637 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)){
1638           self->Disconnect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1645          return self->Empty();
1646       }
1647 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1648         return self->GetConnectionCount();
1649       }
1650 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 &)){
1651           self->Connect( func );
1652       }
1653 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 &)){
1654           self->Disconnect( func );
1655       }
1656 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){
1657           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1658 /*@SWIG@*/ self->Emit( arg );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1661          return self->Empty();
1662       }
1663 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){
1664         return self->GetConnectionCount();
1665       }
1666 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)){
1667         self->Connect( func );
1668       }
1669 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)){
1670         self->Disconnect( func );
1671       }
1672 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){
1673         return self->Emit( arg1, arg2 );
1674       }
1675 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1676          return self->Empty();
1677       }
1678 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){
1679         return self->GetConnectionCount();
1680       }
1681 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)){
1682         self->Connect( func );
1683       }
1684 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)){
1685         self->Disconnect( func );
1686       }
1687 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){
1688         return self->Emit( arg1, arg2 );
1689       }
1690
1691 /* ---------------------------------------------------
1692  * C++ director class methods
1693  * --------------------------------------------------- */
1694
1695 #include "dali_wrap.h"
1696
1697 /*
1698  *  Widget director
1699  */
1700 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1701   swig_init_callbacks();
1702 }
1703
1704 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1705 }
1706
1707 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1708   char * jcontentInfo = 0 ;
1709   void * jwindow  ;
1710
1711   if (!swig_callbackOnCreate) {
1712     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1713     return;
1714   } else {
1715     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1716     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1717     swig_callbackOnCreate(jcontentInfo, jwindow);
1718   }
1719 }
1720
1721 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1722   char * jcontentInfo = 0 ;
1723   int jtype  ;
1724
1725   if (!swig_callbackOnTerminate) {
1726     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1727     return;
1728   } else {
1729     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1730     jtype = (int)type;
1731     swig_callbackOnTerminate(jcontentInfo, jtype);
1732   }
1733 }
1734
1735 void SwigDirector_WidgetImpl::OnPause() {
1736   if (!swig_callbackOnPause) {
1737     Dali::Internal::Adaptor::Widget::OnPause();
1738     return;
1739   } else {
1740     swig_callbackOnPause();
1741   }
1742 }
1743
1744 void SwigDirector_WidgetImpl::OnResume() {
1745   if (!swig_callbackOnResume) {
1746     Dali::Internal::Adaptor::Widget::OnResume();
1747     return;
1748   } else {
1749     swig_callbackOnResume();
1750   }
1751 }
1752
1753 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1754   void * jwindow  ;
1755
1756   if (!swig_callbackOnResize) {
1757     Dali::Internal::Adaptor::Widget::OnResize(window);
1758     return;
1759   } else {
1760     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1761     swig_callbackOnResize(jwindow);
1762   }
1763 }
1764
1765 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1766   char * jcontentInfo = 0 ;
1767   int jforce  ;
1768
1769   if (!swig_callbackOnUpdate) {
1770     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1771     return;
1772   } else {
1773     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1774     jforce = force;
1775     swig_callbackOnUpdate(jcontentInfo, jforce);
1776   }
1777 }
1778
1779 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1780   void * jslotObserver = 0 ;
1781   void * jcallback = 0 ;
1782
1783   if (!swig_callbackSignalConnected) {
1784     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1785     return;
1786   } else {
1787     jslotObserver = (void *) slotObserver;
1788     jcallback = (void *) callback;
1789     swig_callbackSignalConnected(jslotObserver, jcallback);
1790   }
1791 }
1792
1793 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1794   void * jslotObserver = 0 ;
1795   void * jcallback = 0 ;
1796
1797   if (!swig_callbackSignalDisconnected) {
1798     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1799     return;
1800   } else {
1801     jslotObserver = (void *) slotObserver;
1802     jcallback = (void *) callback;
1803     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1804   }
1805 }
1806
1807 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) {
1808
1809   swig_callbackOnCreate = callbackOnCreate;
1810   swig_callbackOnTerminate = callbackOnTerminate;
1811   swig_callbackOnPause = callbackOnPause;
1812   swig_callbackOnResume = callbackOnResume;
1813   swig_callbackOnResize = callbackOnResize;
1814   swig_callbackOnUpdate = callbackOnUpdate;
1815   swig_callbackSignalConnected = callbackSignalConnected;
1816   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1817 }
1818
1819 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1820   swig_callbackOnCreate = 0;
1821   swig_callbackOnTerminate = 0;
1822   swig_callbackOnPause = 0;
1823   swig_callbackOnResume = 0;
1824   swig_callbackOnResize = 0;
1825   swig_callbackOnUpdate = 0;
1826   swig_callbackSignalConnected = 0;
1827   swig_callbackSignalDisconnected = 0;
1828 }
1829
1830
1831 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1832   swig_init_callbacks();
1833 }
1834
1835 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1836
1837 }
1838
1839
1840 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1841   int jdepth  ;
1842
1843   if (!swig_callbackOnStageConnection) {
1844     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1845     return;
1846   } else {
1847     jdepth = depth;
1848     swig_callbackOnStageConnection(jdepth);
1849   }
1850 }
1851
1852 void SwigDirector_ViewImpl::OnStageDisconnection() {
1853   if (!swig_callbackOnStageDisconnection) {
1854     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1855     return;
1856   } else {
1857     swig_callbackOnStageDisconnection();
1858   }
1859 }
1860
1861 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1862   void * jchild = 0 ;
1863
1864   if (!swig_callbackOnChildAdd) {
1865     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1866     return;
1867   } else {
1868     jchild = (Dali::Actor *) &child;
1869     swig_callbackOnChildAdd(jchild);
1870   }
1871 }
1872
1873 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1874   void * jchild = 0 ;
1875
1876   if (!swig_callbackOnChildRemove) {
1877     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1878     return;
1879   } else {
1880     jchild = (Dali::Actor *) &child;
1881     swig_callbackOnChildRemove(jchild);
1882   }
1883 }
1884
1885 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1886   int jindex  ;
1887   void * jpropertyValue  ;
1888
1889   if (!swig_callbackOnPropertySet) {
1890     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1891     return;
1892   } else {
1893     jindex = index;
1894     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1895     swig_callbackOnPropertySet(jindex, jpropertyValue);
1896   }
1897 }
1898
1899 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1900   void * jtargetSize = 0 ;
1901
1902   if (!swig_callbackOnSizeSet) {
1903     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1904     return;
1905   } else {
1906     jtargetSize = (Dali::Vector3 *) &targetSize;
1907     swig_callbackOnSizeSet(jtargetSize);
1908   }
1909 }
1910
1911 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1912   void * janimation = 0 ;
1913   void * jtargetSize = 0 ;
1914
1915   if (!swig_callbackOnSizeAnimation) {
1916     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1917     return;
1918   } else {
1919     janimation = (Dali::Animation *) &animation;
1920     jtargetSize = (Dali::Vector3 *) &targetSize;
1921     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1922   }
1923 }
1924
1925 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1926   bool c_result = SwigValueInit< bool >() ;
1927   unsigned int jresult = 0 ;
1928   void * jarg0 = 0 ;
1929
1930   if (!swig_callbackOnTouchEvent) {
1931     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1932   } else {
1933     jarg0 = (Dali::TouchEvent *) &event;
1934     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1935     c_result = jresult ? true : false;
1936   }
1937   return c_result;
1938 }
1939
1940 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1941   bool c_result = SwigValueInit< bool >() ;
1942   unsigned int jresult = 0 ;
1943   void * jarg0 = 0 ;
1944
1945   if (!swig_callbackOnHoverEvent) {
1946     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1947   } else {
1948     jarg0 = (Dali::HoverEvent *) &event;
1949     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1950     c_result = jresult ? true : false;
1951   }
1952   return c_result;
1953 }
1954
1955 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1956   bool c_result = SwigValueInit< bool >() ;
1957   unsigned int jresult = 0 ;
1958   void * jarg0 = 0 ;
1959
1960   if (!swig_callbackOnKeyEvent) {
1961     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1962   } else {
1963     jarg0 = (Dali::KeyEvent *) &event;
1964     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1965     c_result = jresult ? true : false;
1966   }
1967   return c_result;
1968 }
1969
1970 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1971   bool c_result = SwigValueInit< bool >() ;
1972   unsigned int jresult = 0 ;
1973   void * jarg0 = 0 ;
1974
1975   if (!swig_callbackOnWheelEvent) {
1976     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1977   } else {
1978     jarg0 = (Dali::WheelEvent *) &event;
1979     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1980     c_result = jresult ? true : false;
1981   }
1982   return c_result;
1983 }
1984
1985 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1986   void * jsize = 0 ;
1987   void * jcontainer = 0 ;
1988
1989   if (!swig_callbackOnRelayout) {
1990     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1991     return;
1992   } else {
1993     jsize = (Dali::Vector2 *) &size;
1994     jcontainer = (Dali::RelayoutContainer *) &container;
1995     swig_callbackOnRelayout(jsize, jcontainer);
1996   }
1997 }
1998
1999 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2000   int jpolicy  ;
2001   int jdimension  ;
2002
2003   if (!swig_callbackOnSetResizePolicy) {
2004     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2005     return;
2006   } else {
2007     jpolicy = (int)policy;
2008     jdimension = (int)dimension;
2009     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2010   }
2011 }
2012
2013 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2014   Dali::Vector3 c_result ;
2015   void * jresult = 0 ;
2016
2017   if (!swig_callbackGetNaturalSize) {
2018     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2019   } else {
2020     jresult = (void *) swig_callbackGetNaturalSize();
2021     if (!jresult) {
2022       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2023       return c_result;
2024     }
2025     c_result = *(Dali::Vector3 *)jresult;
2026   }
2027   return c_result;
2028 }
2029
2030 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2031   float c_result = SwigValueInit< float >() ;
2032   float jresult = 0 ;
2033   void * jchild = 0 ;
2034   int jdimension  ;
2035
2036   if (!swig_callbackCalculateChildSize) {
2037     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2038   } else {
2039     jchild = (Dali::Actor *) &child;
2040     jdimension = (int)dimension;
2041     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2042     c_result = (float)jresult;
2043   }
2044   return c_result;
2045 }
2046
2047 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2048   float c_result = SwigValueInit< float >() ;
2049   float jresult = 0 ;
2050   float jwidth  ;
2051
2052   if (!swig_callbackGetHeightForWidth) {
2053     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2054   } else {
2055     jwidth = width;
2056     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2057     c_result = (float)jresult;
2058   }
2059   return c_result;
2060 }
2061
2062 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2063   float c_result = SwigValueInit< float >() ;
2064   float jresult = 0 ;
2065   float jheight  ;
2066
2067   if (!swig_callbackGetWidthForHeight) {
2068     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2069   } else {
2070     jheight = height;
2071     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2072     c_result = (float)jresult;
2073   }
2074   return c_result;
2075 }
2076
2077 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2078   bool c_result = SwigValueInit< bool >() ;
2079   unsigned int jresult = 0 ;
2080   int jdimension  ;
2081
2082   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2083     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2084   } else {
2085     jdimension = (int)dimension;
2086     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2087     c_result = jresult ? true : false;
2088   }
2089   return c_result;
2090 }
2091
2092 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2093   int jdimension  ;
2094
2095   if (!swig_callbackOnCalculateRelayoutSize) {
2096     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2097     return;
2098   } else {
2099     jdimension = (int)dimension;
2100     swig_callbackOnCalculateRelayoutSize(jdimension);
2101   }
2102 }
2103
2104 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2105   float jsize  ;
2106   int jdimension  ;
2107
2108   if (!swig_callbackOnLayoutNegotiated) {
2109     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2110     return;
2111   } else {
2112     jsize = size;
2113     jdimension = (int)dimension;
2114     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2115   }
2116 }
2117
2118 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2119   return Dali::CustomActorImpl::GetExtension();
2120 }
2121
2122 void SwigDirector_ViewImpl::OnInitialize() {
2123   if (!swig_callbackOnInitialize) {
2124     Dali::Toolkit::Internal::Control::OnInitialize();
2125     return;
2126   } else {
2127     swig_callbackOnInitialize();
2128   }
2129 }
2130
2131 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2132   void * jchild = 0 ;
2133
2134   if (!swig_callbackOnControlChildAdd) {
2135     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2136     return;
2137   } else {
2138     jchild = (Dali::Actor *) &child;
2139     swig_callbackOnControlChildAdd(jchild);
2140   }
2141 }
2142
2143 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2144   void * jchild = 0 ;
2145
2146   if (!swig_callbackOnControlChildRemove) {
2147     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2148     return;
2149   } else {
2150     jchild = (Dali::Actor *) &child;
2151     swig_callbackOnControlChildRemove(jchild);
2152   }
2153 }
2154
2155 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2156   void * jstyleManager  ;
2157   int jchange  ;
2158
2159   if (!swig_callbackOnStyleChange) {
2160     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2161     return;
2162   } else {
2163     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2164     jchange = (int)change;
2165     swig_callbackOnStyleChange(jstyleManager, jchange);
2166   }
2167 }
2168
2169 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2170   bool c_result = SwigValueInit< bool >() ;
2171   unsigned int jresult = 0 ;
2172
2173   if (!swig_callbackOnAccessibilityActivated) {
2174     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2175   } else {
2176     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2177     c_result = jresult ? true : false;
2178   }
2179   return c_result;
2180 }
2181
2182 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2183   bool c_result = SwigValueInit< bool >() ;
2184   unsigned int jresult = 0 ;
2185   void * jgesture  ;
2186
2187   if (!swig_callbackOnAccessibilityPan) {
2188     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2189   } else {
2190     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2191     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2192     c_result = jresult ? true : false;
2193   }
2194   return c_result;
2195 }
2196
2197 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2198   bool c_result = SwigValueInit< bool >() ;
2199   unsigned int jresult = 0 ;
2200   void * jtouchEvent = 0 ;
2201
2202   if (!swig_callbackOnAccessibilityTouch) {
2203     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2204   } else {
2205     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2206     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2207     c_result = jresult ? true : false;
2208   }
2209   return c_result;
2210 }
2211
2212 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2213   bool c_result = SwigValueInit< bool >() ;
2214   unsigned int jresult = 0 ;
2215   unsigned int jisIncrease  ;
2216
2217   if (!swig_callbackOnAccessibilityValueChange) {
2218     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2219   } else {
2220     jisIncrease = isIncrease;
2221     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2222     c_result = jresult ? true : false;
2223   }
2224   return c_result;
2225 }
2226
2227 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2228   bool c_result = SwigValueInit< bool >() ;
2229   unsigned int jresult = 0 ;
2230
2231   if (!swig_callbackOnAccessibilityZoom) {
2232     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2233   } else {
2234     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2235     c_result = jresult ? true : false;
2236   }
2237   return c_result;
2238 }
2239
2240 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2241   if (!swig_callbackOnKeyInputFocusGained) {
2242     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2243     return;
2244   } else {
2245     swig_callbackOnKeyInputFocusGained();
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2250   if (!swig_callbackOnKeyInputFocusLost) {
2251     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2252     return;
2253   } else {
2254     swig_callbackOnKeyInputFocusLost();
2255   }
2256 }
2257
2258 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2259   Dali::Actor c_result ;
2260   void * jresult = 0 ;
2261   void * jcurrentFocusedActor  ;
2262   int jdirection  ;
2263   unsigned int jloopEnabled  ;
2264
2265   if (!swig_callbackGetNextKeyboardFocusableActor) {
2266     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2267   } else {
2268     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2269     jdirection = (int)direction;
2270     jloopEnabled = loopEnabled;
2271     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2272     if (!jresult) {
2273       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2274       return c_result;
2275     }
2276     c_result = *(Dali::Actor *)jresult;
2277   }
2278   return c_result;
2279 }
2280
2281 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2282   void * jcommitedFocusableActor  ;
2283
2284   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2285     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2286     return;
2287   } else {
2288     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2289     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2290   }
2291 }
2292
2293 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2294   bool c_result = SwigValueInit< bool >() ;
2295   unsigned int jresult = 0 ;
2296
2297   if (!swig_callbackOnKeyboardEnter) {
2298     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2299   } else {
2300     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2301     c_result = jresult ? true : false;
2302   }
2303   return c_result;
2304 }
2305
2306 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2307   void * jpinch = 0 ;
2308
2309   if (!swig_callbackOnPinch) {
2310     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2311     return;
2312   } else {
2313     jpinch = (Dali::PinchGesture *) &pinch;
2314     swig_callbackOnPinch(jpinch);
2315   }
2316 }
2317
2318 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2319   void * jpan = 0 ;
2320
2321   if (!swig_callbackOnPan) {
2322     Dali::Toolkit::Internal::Control::OnPan(pan);
2323     return;
2324   } else {
2325     jpan = (Dali::PanGesture *) &pan;
2326     swig_callbackOnPan(jpan);
2327   }
2328 }
2329
2330 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2331   void * jtap = 0 ;
2332
2333   if (!swig_callbackOnTap) {
2334     Dali::Toolkit::Internal::Control::OnTap(tap);
2335     return;
2336   } else {
2337     jtap = (Dali::TapGesture *) &tap;
2338     swig_callbackOnTap(jtap);
2339   }
2340 }
2341
2342 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2343   void * jlongPress = 0 ;
2344
2345   if (!swig_callbackOnLongPress) {
2346     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2347     return;
2348   } else {
2349     jlongPress = (Dali::LongPressGesture *) &longPress;
2350     swig_callbackOnLongPress(jlongPress);
2351   }
2352 }
2353
2354 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2355   void * jslotObserver = 0 ;
2356   void * jcallback = 0 ;
2357
2358   if (!swig_callbackSignalConnected) {
2359     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2360     return;
2361   } else {
2362     jslotObserver = (void *) slotObserver;
2363     jcallback = (void *) callback;
2364     swig_callbackSignalConnected(jslotObserver, jcallback);
2365   }
2366 }
2367
2368 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2369   void * jslotObserver = 0 ;
2370   void * jcallback = 0 ;
2371
2372   if (!swig_callbackSignalDisconnected) {
2373     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2374     return;
2375   } else {
2376     jslotObserver = (void *) slotObserver;
2377     jcallback = (void *) callback;
2378     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2379   }
2380 }
2381
2382 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2383   return Dali::Toolkit::Internal::Control::GetControlExtension();
2384 }
2385
2386 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) {
2387   swig_callbackOnStageConnection = callbackOnStageConnection;
2388   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2389   swig_callbackOnChildAdd = callbackOnChildAdd;
2390   swig_callbackOnChildRemove = callbackOnChildRemove;
2391   swig_callbackOnPropertySet = callbackOnPropertySet;
2392   swig_callbackOnSizeSet = callbackOnSizeSet;
2393   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2394   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2395   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2396   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2397   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2398   swig_callbackOnRelayout = callbackOnRelayout;
2399   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2400   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2401   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2402   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2403   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2405   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2406   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2407   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2408   swig_callbackOnInitialize = callbackOnInitialize;
2409   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2410   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2411   swig_callbackOnStyleChange = callbackOnStyleChange;
2412   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2413   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2414   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2415   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2416   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2417   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2418   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2419   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2420   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2421   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2422   swig_callbackOnPinch = callbackOnPinch;
2423   swig_callbackOnPan = callbackOnPan;
2424   swig_callbackOnTap = callbackOnTap;
2425   swig_callbackOnLongPress = callbackOnLongPress;
2426   swig_callbackSignalConnected = callbackSignalConnected;
2427   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2428 }
2429
2430 void SwigDirector_ViewImpl::swig_init_callbacks() {
2431   swig_callbackOnStageConnection = 0;
2432   swig_callbackOnStageDisconnection = 0;
2433   swig_callbackOnChildAdd = 0;
2434   swig_callbackOnChildRemove = 0;
2435   swig_callbackOnPropertySet = 0;
2436   swig_callbackOnSizeSet = 0;
2437   swig_callbackOnSizeAnimation = 0;
2438   swig_callbackOnTouchEvent = 0;
2439   swig_callbackOnHoverEvent = 0;
2440   swig_callbackOnKeyEvent = 0;
2441   swig_callbackOnWheelEvent = 0;
2442   swig_callbackOnRelayout = 0;
2443   swig_callbackOnSetResizePolicy = 0;
2444   swig_callbackGetNaturalSize = 0;
2445   swig_callbackCalculateChildSize = 0;
2446   swig_callbackGetHeightForWidth = 0;
2447   swig_callbackGetWidthForHeight = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2449   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2450   swig_callbackOnCalculateRelayoutSize = 0;
2451   swig_callbackOnLayoutNegotiated = 0;
2452   swig_callbackOnInitialize = 0;
2453   swig_callbackOnControlChildAdd = 0;
2454   swig_callbackOnControlChildRemove = 0;
2455   swig_callbackOnStyleChange = 0;
2456   swig_callbackOnAccessibilityActivated = 0;
2457   swig_callbackOnAccessibilityPan = 0;
2458   swig_callbackOnAccessibilityTouch = 0;
2459   swig_callbackOnAccessibilityValueChange = 0;
2460   swig_callbackOnAccessibilityZoom = 0;
2461   swig_callbackOnKeyInputFocusGained = 0;
2462   swig_callbackOnKeyInputFocusLost = 0;
2463   swig_callbackGetNextKeyboardFocusableActor = 0;
2464   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2465   swig_callbackOnKeyboardEnter = 0;
2466   swig_callbackOnPinch = 0;
2467   swig_callbackOnPan = 0;
2468   swig_callbackOnTap = 0;
2469   swig_callbackOnLongPress = 0;
2470   swig_callbackSignalConnected = 0;
2471   swig_callbackSignalDisconnected = 0;
2472 }
2473
2474 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2475   swig_init_callbacks();
2476 }
2477
2478 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2479
2480 }
2481
2482
2483 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2484   unsigned int c_result = SwigValueInit< unsigned int >() ;
2485   unsigned int jresult = 0 ;
2486
2487   if (!swig_callbackGetNumberOfItems) {
2488     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2489   } else {
2490     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2491     c_result = (unsigned int)jresult;
2492   }
2493   return c_result;
2494 }
2495
2496 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2497   Dali::Actor c_result ;
2498   void * jresult = 0 ;
2499   unsigned int jitemId  ;
2500
2501   if (!swig_callbackNewItem) {
2502     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2503   } else {
2504     jitemId = itemId;
2505     jresult = (void *) swig_callbackNewItem(jitemId);
2506     if (!jresult) {
2507       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2508       return c_result;
2509     }
2510     c_result = *(Dali::Actor *)jresult;
2511   }
2512   return c_result;
2513 }
2514
2515 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2516   unsigned int jitemId  ;
2517   void * jactor  ;
2518
2519   if (!swig_callbackItemReleased) {
2520     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2521     return;
2522   } else {
2523     jitemId = itemId;
2524     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2525     swig_callbackItemReleased(jitemId, jactor);
2526   }
2527 }
2528
2529 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2530   return Dali::Toolkit::ItemFactory::GetExtension();
2531 }
2532
2533 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2534   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2535   swig_callbackNewItem = callbackNewItem;
2536   swig_callbackItemReleased = callbackItemReleased;
2537 }
2538
2539 void SwigDirector_ItemFactory::swig_init_callbacks() {
2540   swig_callbackGetNumberOfItems = 0;
2541   swig_callbackNewItem = 0;
2542   swig_callbackItemReleased = 0;
2543 }
2544
2545 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2546   swig_init_callbacks();
2547 }
2548
2549 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2550
2551 }
2552
2553
2554 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2555   Dali::Actor c_result ;
2556   void * jresult = 0 ;
2557   void * jcurrent  ;
2558   void * jproposed  ;
2559   int jdirection  ;
2560
2561   if (!swig_callbackGetNextFocusableActor) {
2562     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2563   } else {
2564     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2565     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2566     jdirection = (int)direction;
2567     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2568     if (!jresult) {
2569       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2570       return c_result;
2571     }
2572     c_result = *(Dali::Actor *)jresult;
2573   }
2574   return c_result;
2575 }
2576
2577 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2578   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2579 }
2580
2581 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2582   swig_callbackGetNextFocusableActor = 0;
2583 }
2584
2585
2586 #ifdef __cplusplus
2587 extern "C" {
2588 #endif
2589
2590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2591   void * jresult ;
2592   floatp *result = 0 ;
2593
2594   {
2595     try {
2596       result = (floatp *)new_floatp();
2597     } catch (std::out_of_range& e) {
2598       {
2599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2600       };
2601     } catch (std::exception& e) {
2602       {
2603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2604       };
2605     } catch (DaliException e) {
2606       {
2607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2612       };
2613     }
2614   }
2615   jresult = (void *)result;
2616   return jresult;
2617 }
2618
2619
2620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2621   floatp *arg1 = (floatp *) 0 ;
2622
2623   arg1 = (floatp *)jarg1;
2624   {
2625     try {
2626       delete_floatp(arg1);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2634       };
2635     } catch (Dali::DaliException e) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2638       };
2639     } catch (...) {
2640       {
2641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2642       };
2643     }
2644   }
2645
2646 }
2647
2648
2649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2650   floatp *arg1 = (floatp *) 0 ;
2651   float arg2 ;
2652
2653   arg1 = (floatp *)jarg1;
2654   arg2 = (float)jarg2;
2655   {
2656     try {
2657       floatp_assign(arg1,arg2);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2665       };
2666     } catch (Dali::DaliException e) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2669       };
2670     } catch (...) {
2671       {
2672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2673       };
2674     }
2675   }
2676
2677 }
2678
2679
2680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2681   float jresult ;
2682   floatp *arg1 = (floatp *) 0 ;
2683   float result;
2684
2685   arg1 = (floatp *)jarg1;
2686   {
2687     try {
2688       result = (float)floatp_value(arg1);
2689     } catch (std::out_of_range& e) {
2690       {
2691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2692       };
2693     } catch (std::exception& e) {
2694       {
2695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2696       };
2697     } catch (DaliException e) {
2698       {
2699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2700       };
2701     } catch (...) {
2702       {
2703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2704       };
2705     }
2706   }
2707   jresult = result;
2708   return jresult;
2709 }
2710
2711
2712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2713   void * jresult ;
2714   floatp *arg1 = (floatp *) 0 ;
2715   float *result = 0 ;
2716
2717   arg1 = (floatp *)jarg1;
2718   {
2719     try {
2720       result = (float *)floatp_cast(arg1);
2721     } catch (std::out_of_range& e) {
2722       {
2723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2724       };
2725     } catch (std::exception& e) {
2726       {
2727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2728       };
2729     } catch (Dali::DaliException e) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2732       };
2733     } catch (...) {
2734       {
2735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2736       };
2737     }
2738   }
2739
2740   jresult = (void *)result;
2741   return jresult;
2742 }
2743
2744
2745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2746   void * jresult ;
2747   float *arg1 = (float *) 0 ;
2748   floatp *result = 0 ;
2749
2750   arg1 = (float *)jarg1;
2751   {
2752     try {
2753       result = (floatp *)floatp_frompointer(arg1);
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2761       };
2762     } catch (Dali::DaliException e) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2765       };
2766     } catch (...) {
2767       {
2768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2769       };
2770     }
2771   }
2772
2773   jresult = (void *)result;
2774   return jresult;
2775 }
2776
2777
2778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2779   void * jresult ;
2780   intp *result = 0 ;
2781
2782   {
2783     try {
2784       result = (intp *)new_intp();
2785     } catch (std::out_of_range& e) {
2786       {
2787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (std::exception& e) {
2790       {
2791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2792       };
2793     } catch (Dali::DaliException e) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2796       };
2797     } catch (...) {
2798       {
2799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2800       };
2801     }
2802   }
2803
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2810   intp *arg1 = (intp *) 0 ;
2811
2812   arg1 = (intp *)jarg1;
2813   {
2814     try {
2815       delete_intp(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (Dali::DaliException e) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2827       };
2828     } catch (...) {
2829       {
2830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2831       };
2832     }
2833   }
2834
2835 }
2836
2837
2838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2839   intp *arg1 = (intp *) 0 ;
2840   int arg2 ;
2841
2842   arg1 = (intp *)jarg1;
2843   arg2 = (int)jarg2;
2844   {
2845     try {
2846       intp_assign(arg1,arg2);
2847     } catch (std::out_of_range& e) {
2848       {
2849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2850       };
2851     } catch (std::exception& e) {
2852       {
2853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2854       };
2855     } catch (Dali::DaliException e) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2858       };
2859     } catch (...) {
2860       {
2861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2862       };
2863     }
2864   }
2865
2866 }
2867
2868
2869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2870   int jresult ;
2871   intp *arg1 = (intp *) 0 ;
2872   int result;
2873
2874   arg1 = (intp *)jarg1;
2875   {
2876     try {
2877       result = (int)intp_value(arg1);
2878     } catch (std::out_of_range& e) {
2879       {
2880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2881       };
2882     } catch (std::exception& e) {
2883       {
2884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2885       };
2886     } catch (Dali::DaliException e) {
2887       {
2888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2889       };
2890     } catch (...) {
2891       {
2892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2893       };
2894     }
2895   }
2896
2897   jresult = result;
2898   return jresult;
2899 }
2900
2901
2902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2903   void * jresult ;
2904   intp *arg1 = (intp *) 0 ;
2905   int *result = 0 ;
2906
2907   arg1 = (intp *)jarg1;
2908   {
2909     try {
2910       result = (int *)intp_cast(arg1);
2911     } catch (std::out_of_range& e) {
2912       {
2913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2914       };
2915     } catch (std::exception& e) {
2916       {
2917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2918       };
2919     } catch (Dali::DaliException e) {
2920       {
2921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2922       };
2923     } catch (...) {
2924       {
2925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2926       };
2927     }
2928   }
2929
2930   jresult = (void *)result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2936   void * jresult ;
2937   int *arg1 = (int *) 0 ;
2938   intp *result = 0 ;
2939
2940   arg1 = (int *)jarg1;
2941   {
2942     try {
2943       result = (intp *)intp_frompointer(arg1);
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (Dali::DaliException e) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2969   void * jresult ;
2970   doublep *result = 0 ;
2971
2972   {
2973     try {
2974       result = (doublep *)new_doublep();
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2982       };
2983     } catch (Dali::DaliException e) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2986       };
2987     } catch (...) {
2988       {
2989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2990       };
2991     }
2992   }
2993
2994   jresult = (void *)result;
2995   return jresult;
2996 }
2997
2998
2999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3000   doublep *arg1 = (doublep *) 0 ;
3001
3002   arg1 = (doublep *)jarg1;
3003   {
3004     try {
3005       delete_doublep(arg1);
3006     } catch (std::out_of_range& e) {
3007       {
3008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (std::exception& e) {
3011       {
3012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3013       };
3014     } catch (Dali::DaliException e) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3017       };
3018     } catch (...) {
3019       {
3020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3021       };
3022     }
3023   }
3024
3025 }
3026
3027
3028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3029   doublep *arg1 = (doublep *) 0 ;
3030   double arg2 ;
3031
3032   arg1 = (doublep *)jarg1;
3033   arg2 = (double)jarg2;
3034   {
3035     try {
3036       doublep_assign(arg1,arg2);
3037     } catch (std::out_of_range& e) {
3038       {
3039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3040       };
3041     } catch (std::exception& e) {
3042       {
3043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3044       };
3045     } catch (Dali::DaliException e) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3052       };
3053     }
3054   }
3055
3056 }
3057
3058
3059 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3060   double jresult ;
3061   doublep *arg1 = (doublep *) 0 ;
3062   double result;
3063
3064   arg1 = (doublep *)jarg1;
3065   {
3066     try {
3067       result = (double)doublep_value(arg1);
3068     } catch (std::out_of_range& e) {
3069       {
3070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3071       };
3072     } catch (std::exception& e) {
3073       {
3074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3075       };
3076     } catch (Dali::DaliException e) {
3077       {
3078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3079       };
3080     } catch (...) {
3081       {
3082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3083       };
3084     }
3085   }
3086
3087   jresult = result;
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3093   void * jresult ;
3094   doublep *arg1 = (doublep *) 0 ;
3095   double *result = 0 ;
3096
3097   arg1 = (doublep *)jarg1;
3098   {
3099     try {
3100       result = (double *)doublep_cast(arg1);
3101     } catch (std::out_of_range& e) {
3102       {
3103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3104       };
3105     } catch (std::exception& e) {
3106       {
3107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3108       };
3109     } catch (Dali::DaliException e) {
3110       {
3111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3112       };
3113     } catch (...) {
3114       {
3115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3116       };
3117     }
3118   }
3119
3120   jresult = (void *)result;
3121   return jresult;
3122 }
3123
3124
3125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3126   void * jresult ;
3127   double *arg1 = (double *) 0 ;
3128   doublep *result = 0 ;
3129
3130   arg1 = (double *)jarg1;
3131   {
3132     try {
3133       result = (doublep *)doublep_frompointer(arg1);
3134     } catch (std::out_of_range& e) {
3135       {
3136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (std::exception& e) {
3139       {
3140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3141       };
3142     } catch (Dali::DaliException e) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3145       };
3146     } catch (...) {
3147       {
3148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3149       };
3150     }
3151   }
3152
3153   jresult = (void *)result;
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3159   void * jresult ;
3160   uintp *result = 0 ;
3161
3162   {
3163     try {
3164       result = (uintp *)new_uintp();
3165     } catch (std::out_of_range& e) {
3166       {
3167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3168       };
3169     } catch (std::exception& e) {
3170       {
3171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3172       };
3173     } catch (Dali::DaliException e) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3176       };
3177     } catch (...) {
3178       {
3179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3180       };
3181     }
3182   }
3183
3184   jresult = (void *)result;
3185   return jresult;
3186 }
3187
3188
3189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3190   uintp *arg1 = (uintp *) 0 ;
3191
3192   arg1 = (uintp *)jarg1;
3193   {
3194     try {
3195       delete_uintp(arg1);
3196     } catch (std::out_of_range& e) {
3197       {
3198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (std::exception& e) {
3201       {
3202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3203       };
3204     } catch (Dali::DaliException e) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3207       };
3208     } catch (...) {
3209       {
3210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3211       };
3212     }
3213   }
3214
3215 }
3216
3217
3218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3219   uintp *arg1 = (uintp *) 0 ;
3220   unsigned int arg2 ;
3221
3222   arg1 = (uintp *)jarg1;
3223   arg2 = (unsigned int)jarg2;
3224   {
3225     try {
3226       uintp_assign(arg1,arg2);
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3234       };
3235     } catch (Dali::DaliException e) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3238       };
3239     } catch (...) {
3240       {
3241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3242       };
3243     }
3244   }
3245
3246 }
3247
3248
3249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3250   unsigned int jresult ;
3251   uintp *arg1 = (uintp *) 0 ;
3252   unsigned int result;
3253
3254   arg1 = (uintp *)jarg1;
3255   {
3256     try {
3257       result = (unsigned int)uintp_value(arg1);
3258     } catch (std::out_of_range& e) {
3259       {
3260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (std::exception& e) {
3263       {
3264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3265       };
3266     } catch (Dali::DaliException e) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3269       };
3270     } catch (...) {
3271       {
3272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3273       };
3274     }
3275   }
3276
3277   jresult = result;
3278   return jresult;
3279 }
3280
3281
3282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3283   void * jresult ;
3284   uintp *arg1 = (uintp *) 0 ;
3285   unsigned int *result = 0 ;
3286
3287   arg1 = (uintp *)jarg1;
3288   {
3289     try {
3290       result = (unsigned int *)uintp_cast(arg1);
3291     } catch (std::out_of_range& e) {
3292       {
3293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (std::exception& e) {
3296       {
3297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3298       };
3299     } catch (Dali::DaliException e) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3302       };
3303     } catch (...) {
3304       {
3305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3306       };
3307     }
3308   }
3309
3310   jresult = (void *)result;
3311   return jresult;
3312 }
3313
3314
3315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3316   void * jresult ;
3317   unsigned int *arg1 = (unsigned int *) 0 ;
3318   uintp *result = 0 ;
3319
3320   arg1 = (unsigned int *)jarg1;
3321   {
3322     try {
3323       result = (uintp *)uintp_frompointer(arg1);
3324     } catch (std::out_of_range& e) {
3325       {
3326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (std::exception& e) {
3329       {
3330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3331       };
3332     } catch (Dali::DaliException e) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3335       };
3336     } catch (...) {
3337       {
3338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3339       };
3340     }
3341   }
3342
3343   jresult = (void *)result;
3344   return jresult;
3345 }
3346
3347
3348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3349   void * jresult ;
3350   ushortp *result = 0 ;
3351
3352   {
3353     try {
3354       result = (ushortp *)new_ushortp();
3355     } catch (std::out_of_range& e) {
3356       {
3357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3358       };
3359     } catch (std::exception& e) {
3360       {
3361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3362       };
3363     } catch (Dali::DaliException e) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3370       };
3371     }
3372   }
3373
3374   jresult = (void *)result;
3375   return jresult;
3376 }
3377
3378
3379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3380   ushortp *arg1 = (ushortp *) 0 ;
3381
3382   arg1 = (ushortp *)jarg1;
3383   {
3384     try {
3385       delete_ushortp(arg1);
3386     } catch (std::out_of_range& e) {
3387       {
3388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (std::exception& e) {
3391       {
3392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3393       };
3394     } catch (Dali::DaliException e) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3401       };
3402     }
3403   }
3404
3405 }
3406
3407
3408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3409   ushortp *arg1 = (ushortp *) 0 ;
3410   unsigned short arg2 ;
3411
3412   arg1 = (ushortp *)jarg1;
3413   arg2 = (unsigned short)jarg2;
3414   {
3415     try {
3416       ushortp_assign(arg1,arg2);
3417     } catch (std::out_of_range& e) {
3418       {
3419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3420       };
3421     } catch (std::exception& e) {
3422       {
3423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3424       };
3425     } catch (Dali::DaliException e) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3432       };
3433     }
3434   }
3435
3436 }
3437
3438
3439 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3440   unsigned short jresult ;
3441   ushortp *arg1 = (ushortp *) 0 ;
3442   unsigned short result;
3443
3444   arg1 = (ushortp *)jarg1;
3445   {
3446     try {
3447       result = (unsigned short)ushortp_value(arg1);
3448     } catch (std::out_of_range& e) {
3449       {
3450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3451       };
3452     } catch (std::exception& e) {
3453       {
3454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3455       };
3456     } catch (Dali::DaliException e) {
3457       {
3458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3459       };
3460     } catch (...) {
3461       {
3462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3463       };
3464     }
3465   }
3466
3467   jresult = result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3473   void * jresult ;
3474   ushortp *arg1 = (ushortp *) 0 ;
3475   unsigned short *result = 0 ;
3476
3477   arg1 = (ushortp *)jarg1;
3478   {
3479     try {
3480       result = (unsigned short *)ushortp_cast(arg1);
3481     } catch (std::out_of_range& e) {
3482       {
3483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (std::exception& e) {
3486       {
3487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (Dali::DaliException e) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499
3500   jresult = (void *)result;
3501   return jresult;
3502 }
3503
3504
3505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3506   void * jresult ;
3507   unsigned short *arg1 = (unsigned short *) 0 ;
3508   ushortp *result = 0 ;
3509
3510   arg1 = (unsigned short *)jarg1;
3511   {
3512     try {
3513       result = (ushortp *)ushortp_frompointer(arg1);
3514     } catch (std::out_of_range& e) {
3515       {
3516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3517       };
3518     } catch (std::exception& e) {
3519       {
3520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3521       };
3522     } catch (Dali::DaliException e) {
3523       {
3524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3525       };
3526     } catch (...) {
3527       {
3528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3529       };
3530     }
3531   }
3532
3533   jresult = (void *)result;
3534   return jresult;
3535 }
3536
3537
3538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3539   unsigned int jresult ;
3540   int arg1 ;
3541   unsigned int result;
3542
3543   arg1 = (int)jarg1;
3544   {
3545     try {
3546       result = (unsigned int)int_to_uint(arg1);
3547     } catch (std::out_of_range& e) {
3548       {
3549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3550       };
3551     } catch (std::exception& e) {
3552       {
3553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3554       };
3555     } catch (Dali::DaliException e) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3558       };
3559     } catch (...) {
3560       {
3561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3562       };
3563     }
3564   }
3565
3566   jresult = result;
3567   return jresult;
3568 }
3569
3570
3571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3572   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3573
3574   arg1 = (Dali::RefObject *)jarg1;
3575   {
3576     try {
3577       (arg1)->Reference();
3578     } catch (std::out_of_range& e) {
3579       {
3580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3581       };
3582     } catch (std::exception& e) {
3583       {
3584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3585       };
3586     } catch (Dali::DaliException e) {
3587       {
3588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3589       };
3590     } catch (...) {
3591       {
3592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3593       };
3594     }
3595   }
3596
3597 }
3598
3599
3600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3601   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3602
3603   arg1 = (Dali::RefObject *)jarg1;
3604   {
3605     try {
3606       (arg1)->Unreference();
3607     } catch (std::out_of_range& e) {
3608       {
3609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3610       };
3611     } catch (std::exception& e) {
3612       {
3613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3614       };
3615     } catch (Dali::DaliException e) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3618       };
3619     } catch (...) {
3620       {
3621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3622       };
3623     }
3624   }
3625
3626 }
3627
3628
3629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3630   int jresult ;
3631   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3632   int result;
3633
3634   arg1 = (Dali::RefObject *)jarg1;
3635   {
3636     try {
3637       result = (int)(arg1)->ReferenceCount();
3638     } catch (std::out_of_range& e) {
3639       {
3640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (std::exception& e) {
3643       {
3644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3645       };
3646     } catch (Dali::DaliException e) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3649       };
3650     } catch (...) {
3651       {
3652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3653       };
3654     }
3655   }
3656
3657   jresult = result;
3658   return jresult;
3659 }
3660
3661
3662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3663   void * jresult ;
3664   Dali::Any *result = 0 ;
3665
3666   {
3667     try {
3668       result = (Dali::Any *)new Dali::Any();
3669     } catch (std::out_of_range& e) {
3670       {
3671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3672       };
3673     } catch (std::exception& e) {
3674       {
3675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3676       };
3677     } catch (Dali::DaliException e) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3680       };
3681     } catch (...) {
3682       {
3683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3684       };
3685     }
3686   }
3687
3688   jresult = (void *)result;
3689   return jresult;
3690 }
3691
3692
3693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3694   Dali::Any *arg1 = (Dali::Any *) 0 ;
3695
3696   arg1 = (Dali::Any *)jarg1;
3697   {
3698     try {
3699       delete arg1;
3700     } catch (std::out_of_range& e) {
3701       {
3702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3703       };
3704     } catch (std::exception& e) {
3705       {
3706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3707       };
3708     } catch (Dali::DaliException e) {
3709       {
3710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3711       };
3712     } catch (...) {
3713       {
3714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3715       };
3716     }
3717   }
3718
3719 }
3720
3721
3722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3723   char *arg1 = (char *) 0 ;
3724
3725   arg1 = (char *)jarg1;
3726   {
3727     try {
3728       Dali::Any::AssertAlways((char const *)arg1);
3729     } catch (std::out_of_range& e) {
3730       {
3731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3732       };
3733     } catch (std::exception& e) {
3734       {
3735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3736       };
3737     } catch (Dali::DaliException e) {
3738       {
3739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3740       };
3741     } catch (...) {
3742       {
3743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3744       };
3745     }
3746   }
3747
3748 }
3749
3750
3751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3752   void * jresult ;
3753   Dali::Any *arg1 = 0 ;
3754   Dali::Any *result = 0 ;
3755
3756   arg1 = (Dali::Any *)jarg1;
3757   if (!arg1) {
3758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3759     return 0;
3760   }
3761   {
3762     try {
3763       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3764     } catch (std::out_of_range& e) {
3765       {
3766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3767       };
3768     } catch (std::exception& e) {
3769       {
3770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3771       };
3772     } catch (Dali::DaliException e) {
3773       {
3774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3775       };
3776     } catch (...) {
3777       {
3778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3779       };
3780     }
3781   }
3782
3783   jresult = (void *)result;
3784   return jresult;
3785 }
3786
3787
3788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3789   void * jresult ;
3790   Dali::Any *arg1 = (Dali::Any *) 0 ;
3791   Dali::Any *arg2 = 0 ;
3792   Dali::Any *result = 0 ;
3793
3794   arg1 = (Dali::Any *)jarg1;
3795   arg2 = (Dali::Any *)jarg2;
3796   if (!arg2) {
3797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3798     return 0;
3799   }
3800   {
3801     try {
3802       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3803     } catch (std::out_of_range& e) {
3804       {
3805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3806       };
3807     } catch (std::exception& e) {
3808       {
3809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3810       };
3811     } catch (Dali::DaliException e) {
3812       {
3813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3814       };
3815     } catch (...) {
3816       {
3817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3818       };
3819     }
3820   }
3821
3822   jresult = (void *)result;
3823   return jresult;
3824 }
3825
3826
3827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3828   void * jresult ;
3829   Dali::Any *arg1 = (Dali::Any *) 0 ;
3830   std::type_info *result = 0 ;
3831
3832   arg1 = (Dali::Any *)jarg1;
3833   {
3834     try {
3835       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3836     } catch (std::out_of_range& e) {
3837       {
3838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3839       };
3840     } catch (std::exception& e) {
3841       {
3842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3843       };
3844     } catch (Dali::DaliException e) {
3845       {
3846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3847       };
3848     } catch (...) {
3849       {
3850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3851       };
3852     }
3853   }
3854
3855   jresult = (void *)result;
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3861   unsigned int jresult ;
3862   Dali::Any *arg1 = (Dali::Any *) 0 ;
3863   bool result;
3864
3865   arg1 = (Dali::Any *)jarg1;
3866   {
3867     try {
3868       result = (bool)((Dali::Any const *)arg1)->Empty();
3869     } catch (std::out_of_range& e) {
3870       {
3871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (std::exception& e) {
3874       {
3875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3876       };
3877     } catch (Dali::DaliException e) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3880       };
3881     } catch (...) {
3882       {
3883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3884       };
3885     }
3886   }
3887
3888   jresult = result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3894   void * jresult ;
3895   std::type_info *arg1 = 0 ;
3896   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3897   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3898   Dali::Any::AnyContainerBase *result = 0 ;
3899
3900   arg1 = (std::type_info *)jarg1;
3901   if (!arg1) {
3902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3903     return 0;
3904   }
3905   arg2 = (Dali::Any::CloneFunc)jarg2;
3906   arg3 = (Dali::Any::DeleteFunc)jarg3;
3907   {
3908     try {
3909       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3910     } catch (std::out_of_range& e) {
3911       {
3912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3913       };
3914     } catch (std::exception& e) {
3915       {
3916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3917       };
3918     } catch (Dali::DaliException e) {
3919       {
3920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3921       };
3922     } catch (...) {
3923       {
3924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3925       };
3926     }
3927   }
3928
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3935   void * jresult ;
3936   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3937   std::type_info *result = 0 ;
3938
3939   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3940   {
3941     try {
3942       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3943     } catch (std::out_of_range& e) {
3944       {
3945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3946       };
3947     } catch (std::exception& e) {
3948       {
3949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3950       };
3951     } catch (Dali::DaliException e) {
3952       {
3953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3954       };
3955     } catch (...) {
3956       {
3957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3958       };
3959     }
3960   }
3961
3962   jresult = (void *)result;
3963   return jresult;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3968   void * jresult ;
3969   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3970   ::std::type_info *result = 0 ;
3971
3972   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3973   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3974   jresult = (void *)result;
3975   return jresult;
3976 }
3977
3978
3979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3980   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3981   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3982
3983   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3984   arg2 = (Dali::Any::CloneFunc)jarg2;
3985   if (arg1) (arg1)->mCloneFunc = arg2;
3986 }
3987
3988
3989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3990   void * jresult ;
3991   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3992   Dali::Any::CloneFunc result;
3993
3994   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3995   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3996   jresult = (void *)result;
3997   return jresult;
3998 }
3999
4000
4001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4002   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4003   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4004
4005   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4006   arg2 = (Dali::Any::DeleteFunc)jarg2;
4007   if (arg1) (arg1)->mDeleteFunc = arg2;
4008 }
4009
4010
4011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4012   void * jresult ;
4013   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4014   Dali::Any::DeleteFunc result;
4015
4016   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4017   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4018   jresult = (void *)result;
4019   return jresult;
4020 }
4021
4022
4023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4024   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4025
4026   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4027   {
4028     try {
4029       delete arg1;
4030     } catch (std::out_of_range& e) {
4031       {
4032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4033       };
4034     } catch (std::exception& e) {
4035       {
4036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4037       };
4038     } catch (Dali::DaliException e) {
4039       {
4040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4041       };
4042     } catch (...) {
4043       {
4044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4045       };
4046     }
4047   }
4048
4049 }
4050
4051
4052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4053   Dali::Any *arg1 = (Dali::Any *) 0 ;
4054   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4055
4056   arg1 = (Dali::Any *)jarg1;
4057   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4058   if (arg1) (arg1)->mContainer = arg2;
4059 }
4060
4061
4062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4063   void * jresult ;
4064   Dali::Any *arg1 = (Dali::Any *) 0 ;
4065   Dali::Any::AnyContainerBase *result = 0 ;
4066
4067   arg1 = (Dali::Any *)jarg1;
4068   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4069   jresult = (void *)result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4075   char *arg1 = (char *) 0 ;
4076   char *arg2 = (char *) 0 ;
4077
4078   arg1 = (char *)jarg1;
4079   arg2 = (char *)jarg2;
4080   {
4081     try {
4082       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4083     } catch (std::out_of_range& e) {
4084       {
4085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4086       };
4087     } catch (std::exception& e) {
4088       {
4089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4090       };
4091     } catch (Dali::DaliException e) {
4092       {
4093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4094       };
4095     } catch (...) {
4096       {
4097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4098       };
4099     }
4100   }
4101
4102 }
4103
4104
4105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4106   void * jresult ;
4107   char *arg1 = (char *) 0 ;
4108   char *arg2 = (char *) 0 ;
4109   Dali::DaliException *result = 0 ;
4110
4111   arg1 = (char *)jarg1;
4112   arg2 = (char *)jarg2;
4113   {
4114     try {
4115       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4116     } catch (std::out_of_range& e) {
4117       {
4118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (std::exception& e) {
4121       {
4122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4123       };
4124     } catch (Dali::DaliException e) {
4125       {
4126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4127       };
4128     } catch (...) {
4129       {
4130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4131       };
4132     }
4133   }
4134
4135   jresult = (void *)result;
4136   return jresult;
4137 }
4138
4139
4140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4141   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4142   std::string arg2 = std::string(jarg2);
4143
4144   arg1 = (Dali::DaliException *)jarg1;
4145   {
4146     if (!arg2.empty()) {
4147       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4148     } else {
4149       arg1->location = 0;
4150     }
4151   }
4152 }
4153
4154 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4155   char * jresult ;
4156   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4157   char *result = 0 ;
4158
4159   arg1 = (Dali::DaliException *)jarg1;
4160   result = (char *) ((arg1)->location);
4161   jresult = SWIG_csharp_string_callback((const char *)result);
4162   return jresult;
4163 }
4164
4165
4166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4167   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4168   std::string arg2 = std::string(jarg2);
4169
4170   arg1 = (Dali::DaliException *)jarg1;
4171   {
4172     if (!arg2.empty()) {
4173       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4174     } else {
4175       arg1->condition = 0;
4176     }
4177   }
4178 }
4179
4180
4181 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4182   char * jresult ;
4183   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4184   char *result = 0 ;
4185
4186   arg1 = (Dali::DaliException *)jarg1;
4187   result = (char *) ((arg1)->condition);
4188   jresult = SWIG_csharp_string_callback((const char *)result);
4189   return jresult;
4190 }
4191
4192
4193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4194   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4195
4196   arg1 = (Dali::DaliException *)jarg1;
4197   {
4198     try {
4199       delete arg1;
4200     } catch (std::out_of_range& e) {
4201       {
4202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4203       };
4204     } catch (std::exception& e) {
4205       {
4206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4207       };
4208     } catch (Dali::DaliException e) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4211       };
4212     } catch (...) {
4213       {
4214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4215       };
4216     }
4217   }
4218
4219 }
4220
4221
4222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4223   void * jresult ;
4224   Dali::Vector2 *result = 0 ;
4225
4226   {
4227     try {
4228       result = (Dali::Vector2 *)new Dali::Vector2();
4229     } catch (std::out_of_range& e) {
4230       {
4231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4232       };
4233     } catch (std::exception& e) {
4234       {
4235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (Dali::DaliException e) {
4238       {
4239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4240       };
4241     } catch (...) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4244       };
4245     }
4246   }
4247
4248   jresult = (void *)result;
4249   return jresult;
4250 }
4251
4252
4253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4254   void * jresult ;
4255   float arg1 ;
4256   float arg2 ;
4257   Dali::Vector2 *result = 0 ;
4258
4259   arg1 = (float)jarg1;
4260   arg2 = (float)jarg2;
4261   {
4262     try {
4263       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4264     } catch (std::out_of_range& e) {
4265       {
4266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (std::exception& e) {
4269       {
4270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4271       };
4272     } catch (Dali::DaliException e) {
4273       {
4274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4275       };
4276     } catch (...) {
4277       {
4278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4279       };
4280     }
4281   }
4282
4283   jresult = (void *)result;
4284   return jresult;
4285 }
4286
4287
4288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4289   void * jresult ;
4290   float *arg1 = (float *) 0 ;
4291   Dali::Vector2 *result = 0 ;
4292
4293   arg1 = jarg1;
4294   {
4295     try {
4296       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4297     } catch (std::out_of_range& e) {
4298       {
4299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (std::exception& e) {
4302       {
4303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4304       };
4305     } catch (Dali::DaliException e) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4308       };
4309     } catch (...) {
4310       {
4311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4312       };
4313     }
4314   }
4315
4316   jresult = (void *)result;
4317
4318
4319   return jresult;
4320 }
4321
4322
4323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4324   void * jresult ;
4325   Dali::Vector3 *arg1 = 0 ;
4326   Dali::Vector2 *result = 0 ;
4327
4328   arg1 = (Dali::Vector3 *)jarg1;
4329   if (!arg1) {
4330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4331     return 0;
4332   }
4333   {
4334     try {
4335       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4336     } catch (std::out_of_range& e) {
4337       {
4338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4339       };
4340     } catch (std::exception& e) {
4341       {
4342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4343       };
4344     } catch (Dali::DaliException e) {
4345       {
4346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4347       };
4348     } catch (...) {
4349       {
4350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4351       };
4352     }
4353   }
4354
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4361   void * jresult ;
4362   Dali::Vector4 *arg1 = 0 ;
4363   Dali::Vector2 *result = 0 ;
4364
4365   arg1 = (Dali::Vector4 *)jarg1;
4366   if (!arg1) {
4367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4368     return 0;
4369   }
4370   {
4371     try {
4372       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4373     } catch (std::out_of_range& e) {
4374       {
4375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (std::exception& e) {
4378       {
4379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4380       };
4381     } catch (Dali::DaliException e) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4384       };
4385     } catch (...) {
4386       {
4387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4388       };
4389     }
4390   }
4391
4392   jresult = (void *)result;
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4398   void * jresult ;
4399   Dali::Vector2 *result = 0 ;
4400
4401   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4402   jresult = (void *)result;
4403   return jresult;
4404 }
4405
4406
4407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4408   void * jresult ;
4409   Dali::Vector2 *result = 0 ;
4410
4411   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4412   jresult = (void *)result;
4413   return jresult;
4414 }
4415
4416
4417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4418   void * jresult ;
4419   Dali::Vector2 *result = 0 ;
4420
4421   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4422   jresult = (void *)result;
4423   return jresult;
4424 }
4425
4426
4427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4428   void * jresult ;
4429   Dali::Vector2 *result = 0 ;
4430
4431   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4432   jresult = (void *)result;
4433   return jresult;
4434 }
4435
4436
4437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4438   void * jresult ;
4439   Dali::Vector2 *result = 0 ;
4440
4441   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4442   jresult = (void *)result;
4443   return jresult;
4444 }
4445
4446
4447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4448   void * jresult ;
4449   Dali::Vector2 *result = 0 ;
4450
4451   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4452   jresult = (void *)result;
4453   return jresult;
4454 }
4455
4456
4457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4458   void * jresult ;
4459   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4460   float *arg2 = (float *) 0 ;
4461   Dali::Vector2 *result = 0 ;
4462
4463   arg1 = (Dali::Vector2 *)jarg1;
4464   arg2 = jarg2;
4465   {
4466     try {
4467       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4468     } catch (std::out_of_range& e) {
4469       {
4470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (std::exception& e) {
4473       {
4474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4475       };
4476     } catch (Dali::DaliException e) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4479       };
4480     } catch (...) {
4481       {
4482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4483       };
4484     }
4485   }
4486
4487   jresult = (void *)result;
4488
4489
4490   return jresult;
4491 }
4492
4493
4494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4495   void * jresult ;
4496   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4497   Dali::Vector3 *arg2 = 0 ;
4498   Dali::Vector2 *result = 0 ;
4499
4500   arg1 = (Dali::Vector2 *)jarg1;
4501   arg2 = (Dali::Vector3 *)jarg2;
4502   if (!arg2) {
4503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4504     return 0;
4505   }
4506   {
4507     try {
4508       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4509     } catch (std::out_of_range& e) {
4510       {
4511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4512       };
4513     } catch (std::exception& e) {
4514       {
4515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4516       };
4517     } catch (Dali::DaliException e) {
4518       {
4519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4520       };
4521     } catch (...) {
4522       {
4523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4524       };
4525     }
4526   }
4527
4528   jresult = (void *)result;
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4534   void * jresult ;
4535   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4536   Dali::Vector4 *arg2 = 0 ;
4537   Dali::Vector2 *result = 0 ;
4538
4539   arg1 = (Dali::Vector2 *)jarg1;
4540   arg2 = (Dali::Vector4 *)jarg2;
4541   if (!arg2) {
4542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4543     return 0;
4544   }
4545   {
4546     try {
4547       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4548     } catch (std::out_of_range& e) {
4549       {
4550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (std::exception& e) {
4553       {
4554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4555       };
4556     } catch (Dali::DaliException e) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4559       };
4560     } catch (...) {
4561       {
4562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4563       };
4564     }
4565   }
4566
4567   jresult = (void *)result;
4568   return jresult;
4569 }
4570
4571
4572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4573   void * jresult ;
4574   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4575   Dali::Vector2 *arg2 = 0 ;
4576   Dali::Vector2 result;
4577
4578   arg1 = (Dali::Vector2 *)jarg1;
4579   arg2 = (Dali::Vector2 *)jarg2;
4580   if (!arg2) {
4581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4582     return 0;
4583   }
4584   {
4585     try {
4586       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4587     } catch (std::out_of_range& e) {
4588       {
4589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (std::exception& e) {
4592       {
4593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4594       };
4595     } catch (Dali::DaliException e) {
4596       {
4597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4598       };
4599     } catch (...) {
4600       {
4601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4602       };
4603     }
4604   }
4605
4606   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4607   return jresult;
4608 }
4609
4610
4611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4612   void * jresult ;
4613   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4614   Dali::Vector2 *arg2 = 0 ;
4615   Dali::Vector2 *result = 0 ;
4616
4617   arg1 = (Dali::Vector2 *)jarg1;
4618   arg2 = (Dali::Vector2 *)jarg2;
4619   if (!arg2) {
4620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4621     return 0;
4622   }
4623   {
4624     try {
4625       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4626     } catch (std::out_of_range& e) {
4627       {
4628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4629       };
4630     } catch (std::exception& e) {
4631       {
4632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4633       };
4634     } catch (Dali::DaliException e) {
4635       {
4636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4637       };
4638     } catch (...) {
4639       {
4640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4641       };
4642     }
4643   }
4644
4645   jresult = (void *)result;
4646   return jresult;
4647 }
4648
4649
4650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4651   void * jresult ;
4652   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4653   Dali::Vector2 *arg2 = 0 ;
4654   Dali::Vector2 result;
4655
4656   arg1 = (Dali::Vector2 *)jarg1;
4657   arg2 = (Dali::Vector2 *)jarg2;
4658   if (!arg2) {
4659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4660     return 0;
4661   }
4662   {
4663     try {
4664       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4665     } catch (std::out_of_range& e) {
4666       {
4667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4668       };
4669     } catch (std::exception& e) {
4670       {
4671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4672       };
4673     } catch (Dali::DaliException e) {
4674       {
4675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4676       };
4677     } catch (...) {
4678       {
4679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4680       };
4681     }
4682   }
4683
4684   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4685   return jresult;
4686 }
4687
4688
4689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4690   void * jresult ;
4691   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4692   Dali::Vector2 *arg2 = 0 ;
4693   Dali::Vector2 *result = 0 ;
4694
4695   arg1 = (Dali::Vector2 *)jarg1;
4696   arg2 = (Dali::Vector2 *)jarg2;
4697   if (!arg2) {
4698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4699     return 0;
4700   }
4701   {
4702     try {
4703       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4704     } catch (std::out_of_range& e) {
4705       {
4706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (std::exception& e) {
4709       {
4710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4711       };
4712     } catch (Dali::DaliException e) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4715       };
4716     } catch (...) {
4717       {
4718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4719       };
4720     }
4721   }
4722
4723   jresult = (void *)result;
4724   return jresult;
4725 }
4726
4727
4728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4729   void * jresult ;
4730   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4731   Dali::Vector2 *arg2 = 0 ;
4732   Dali::Vector2 result;
4733
4734   arg1 = (Dali::Vector2 *)jarg1;
4735   arg2 = (Dali::Vector2 *)jarg2;
4736   if (!arg2) {
4737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4738     return 0;
4739   }
4740   {
4741     try {
4742       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4743     } catch (std::out_of_range& e) {
4744       {
4745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (std::exception& e) {
4748       {
4749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4750       };
4751     } catch (Dali::DaliException e) {
4752       {
4753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4754       };
4755     } catch (...) {
4756       {
4757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4758       };
4759     }
4760   }
4761
4762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4763   return jresult;
4764 }
4765
4766
4767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4768   void * jresult ;
4769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4770   float arg2 ;
4771   Dali::Vector2 result;
4772
4773   arg1 = (Dali::Vector2 *)jarg1;
4774   arg2 = (float)jarg2;
4775   {
4776     try {
4777       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4778     } catch (std::out_of_range& e) {
4779       {
4780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4781       };
4782     } catch (std::exception& e) {
4783       {
4784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4785       };
4786     } catch (Dali::DaliException e) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4789       };
4790     } catch (...) {
4791       {
4792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4793       };
4794     }
4795   }
4796
4797   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4798   return jresult;
4799 }
4800
4801
4802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4803   void * jresult ;
4804   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4805   Dali::Vector2 *arg2 = 0 ;
4806   Dali::Vector2 *result = 0 ;
4807
4808   arg1 = (Dali::Vector2 *)jarg1;
4809   arg2 = (Dali::Vector2 *)jarg2;
4810   if (!arg2) {
4811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4812     return 0;
4813   }
4814   {
4815     try {
4816       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4817     } catch (std::out_of_range& e) {
4818       {
4819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (std::exception& e) {
4822       {
4823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (Dali::DaliException e) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4828       };
4829     } catch (...) {
4830       {
4831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4832       };
4833     }
4834   }
4835
4836   jresult = (void *)result;
4837   return jresult;
4838 }
4839
4840
4841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4842   void * jresult ;
4843   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4844   float arg2 ;
4845   Dali::Vector2 *result = 0 ;
4846
4847   arg1 = (Dali::Vector2 *)jarg1;
4848   arg2 = (float)jarg2;
4849   {
4850     try {
4851       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4852     } catch (std::out_of_range& e) {
4853       {
4854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4855       };
4856     } catch (std::exception& e) {
4857       {
4858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4859       };
4860     } catch (Dali::DaliException e) {
4861       {
4862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4863       };
4864     } catch (...) {
4865       {
4866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4867       };
4868     }
4869   }
4870
4871   jresult = (void *)result;
4872   return jresult;
4873 }
4874
4875
4876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4877   void * jresult ;
4878   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4879   Dali::Vector2 *arg2 = 0 ;
4880   Dali::Vector2 result;
4881
4882   arg1 = (Dali::Vector2 *)jarg1;
4883   arg2 = (Dali::Vector2 *)jarg2;
4884   if (!arg2) {
4885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4886     return 0;
4887   }
4888   {
4889     try {
4890       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4891     } catch (std::out_of_range& e) {
4892       {
4893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (std::exception& e) {
4896       {
4897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4898       };
4899     } catch (Dali::DaliException e) {
4900       {
4901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4902       };
4903     } catch (...) {
4904       {
4905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4906       };
4907     }
4908   }
4909
4910   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4911   return jresult;
4912 }
4913
4914
4915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4916   void * jresult ;
4917   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4918   float arg2 ;
4919   Dali::Vector2 result;
4920
4921   arg1 = (Dali::Vector2 *)jarg1;
4922   arg2 = (float)jarg2;
4923   {
4924     try {
4925       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4926     } catch (std::out_of_range& e) {
4927       {
4928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4929       };
4930     } catch (std::exception& e) {
4931       {
4932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4933       };
4934     } catch (Dali::DaliException e) {
4935       {
4936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4937       };
4938     } catch (...) {
4939       {
4940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4941       };
4942     }
4943   }
4944
4945   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4946   return jresult;
4947 }
4948
4949
4950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4951   void * jresult ;
4952   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4953   Dali::Vector2 *arg2 = 0 ;
4954   Dali::Vector2 *result = 0 ;
4955
4956   arg1 = (Dali::Vector2 *)jarg1;
4957   arg2 = (Dali::Vector2 *)jarg2;
4958   if (!arg2) {
4959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4960     return 0;
4961   }
4962   {
4963     try {
4964       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4965     } catch (std::out_of_range& e) {
4966       {
4967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4968       };
4969     } catch (std::exception& e) {
4970       {
4971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4972       };
4973     } catch (Dali::DaliException e) {
4974       {
4975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4976       };
4977     } catch (...) {
4978       {
4979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4980       };
4981     }
4982   }
4983
4984   jresult = (void *)result;
4985   return jresult;
4986 }
4987
4988
4989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4990   void * jresult ;
4991   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4992   float arg2 ;
4993   Dali::Vector2 *result = 0 ;
4994
4995   arg1 = (Dali::Vector2 *)jarg1;
4996   arg2 = (float)jarg2;
4997   {
4998     try {
4999       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5000     } catch (std::out_of_range& e) {
5001       {
5002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5003       };
5004     } catch (std::exception& e) {
5005       {
5006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5007       };
5008     } catch (Dali::DaliException e) {
5009       {
5010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5011       };
5012     } catch (...) {
5013       {
5014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5015       };
5016     }
5017   }
5018
5019   jresult = (void *)result;
5020   return jresult;
5021 }
5022
5023
5024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5025   void * jresult ;
5026   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5027   Dali::Vector2 result;
5028
5029   arg1 = (Dali::Vector2 *)jarg1;
5030   {
5031     try {
5032       result = ((Dali::Vector2 const *)arg1)->operator -();
5033     } catch (std::out_of_range& e) {
5034       {
5035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5036       };
5037     } catch (std::exception& e) {
5038       {
5039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5040       };
5041     } catch (Dali::DaliException e) {
5042       {
5043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5044       };
5045     } catch (...) {
5046       {
5047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5048       };
5049     }
5050   }
5051
5052   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5053   return jresult;
5054 }
5055
5056
5057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5058   unsigned int jresult ;
5059   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5060   Dali::Vector2 *arg2 = 0 ;
5061   bool result;
5062
5063   arg1 = (Dali::Vector2 *)jarg1;
5064   arg2 = (Dali::Vector2 *)jarg2;
5065   if (!arg2) {
5066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5067     return 0;
5068   }
5069   {
5070     try {
5071       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5072     } catch (std::out_of_range& e) {
5073       {
5074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (std::exception& e) {
5077       {
5078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5079       };
5080     } catch (Dali::DaliException e) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5083       };
5084     } catch (...) {
5085       {
5086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5087       };
5088     }
5089   }
5090
5091   jresult = result;
5092   return jresult;
5093 }
5094
5095
5096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5097   unsigned int jresult ;
5098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5099   Dali::Vector2 *arg2 = 0 ;
5100   bool result;
5101
5102   arg1 = (Dali::Vector2 *)jarg1;
5103   arg2 = (Dali::Vector2 *)jarg2;
5104   if (!arg2) {
5105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5106     return 0;
5107   }
5108   {
5109     try {
5110       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5111     } catch (std::out_of_range& e) {
5112       {
5113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5114       };
5115     } catch (std::exception& e) {
5116       {
5117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5118       };
5119     } catch (Dali::DaliException e) {
5120       {
5121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5122       };
5123     } catch (...) {
5124       {
5125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5126       };
5127     }
5128   }
5129
5130   jresult = result;
5131   return jresult;
5132 }
5133
5134
5135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5136   float jresult ;
5137   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5138   unsigned int arg2 ;
5139   float *result = 0 ;
5140
5141   arg1 = (Dali::Vector2 *)jarg1;
5142   arg2 = (unsigned int)jarg2;
5143   {
5144     try {
5145       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5146     } catch (std::out_of_range& e) {
5147       {
5148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5149       };
5150     } catch (std::exception& e) {
5151       {
5152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5153       };
5154     } catch (Dali::DaliException e) {
5155       {
5156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5157       };
5158     } catch (...) {
5159       {
5160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5161       };
5162     }
5163   }
5164
5165   jresult = *result;
5166   return jresult;
5167 }
5168
5169
5170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5171   float jresult ;
5172   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5173   float result;
5174
5175   arg1 = (Dali::Vector2 *)jarg1;
5176   {
5177     try {
5178       result = (float)((Dali::Vector2 const *)arg1)->Length();
5179     } catch (std::out_of_range& e) {
5180       {
5181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5182       };
5183     } catch (std::exception& e) {
5184       {
5185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5186       };
5187     } catch (Dali::DaliException e) {
5188       {
5189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5190       };
5191     } catch (...) {
5192       {
5193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5194       };
5195     }
5196   }
5197
5198   jresult = result;
5199   return jresult;
5200 }
5201
5202
5203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5204   float jresult ;
5205   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5206   float result;
5207
5208   arg1 = (Dali::Vector2 *)jarg1;
5209   {
5210     try {
5211       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5212     } catch (std::out_of_range& e) {
5213       {
5214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5215       };
5216     } catch (std::exception& e) {
5217       {
5218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5219       };
5220     } catch (Dali::DaliException e) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5223       };
5224     } catch (...) {
5225       {
5226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5227       };
5228     }
5229   }
5230
5231   jresult = result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5237   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5238
5239   arg1 = (Dali::Vector2 *)jarg1;
5240   {
5241     try {
5242       (arg1)->Normalize();
5243     } catch (std::out_of_range& e) {
5244       {
5245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (std::exception& e) {
5248       {
5249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5250       };
5251     } catch (Dali::DaliException e) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5254       };
5255     } catch (...) {
5256       {
5257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5258       };
5259     }
5260   }
5261
5262 }
5263
5264
5265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5266   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5267   Dali::Vector2 *arg2 = 0 ;
5268   Dali::Vector2 *arg3 = 0 ;
5269
5270   arg1 = (Dali::Vector2 *)jarg1;
5271   arg2 = (Dali::Vector2 *)jarg2;
5272   if (!arg2) {
5273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5274     return ;
5275   }
5276   arg3 = (Dali::Vector2 *)jarg3;
5277   if (!arg3) {
5278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5279     return ;
5280   }
5281   {
5282     try {
5283       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5284     } catch (std::out_of_range& e) {
5285       {
5286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5287       };
5288     } catch (std::exception& e) {
5289       {
5290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5291       };
5292     } catch (Dali::DaliException e) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5295       };
5296     } catch (...) {
5297       {
5298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5299       };
5300     }
5301   }
5302
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5307   void * jresult ;
5308   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5309   float *result = 0 ;
5310
5311   arg1 = (Dali::Vector2 *)jarg1;
5312   {
5313     try {
5314       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5315     } catch (std::out_of_range& e) {
5316       {
5317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5318       };
5319     } catch (std::exception& e) {
5320       {
5321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5322       };
5323     } catch (Dali::DaliException e) {
5324       {
5325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5326       };
5327     } catch (...) {
5328       {
5329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5330       };
5331     }
5332   }
5333
5334   jresult = (void *)result;
5335   return jresult;
5336 }
5337
5338
5339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5340   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5341   float arg2 ;
5342
5343   arg1 = (Dali::Vector2 *)jarg1;
5344   arg2 = (float)jarg2;
5345   if (arg1) (arg1)->x = arg2;
5346 }
5347
5348
5349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5350   float jresult ;
5351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5352   float result;
5353
5354   arg1 = (Dali::Vector2 *)jarg1;
5355   result = (float) ((arg1)->x);
5356   jresult = result;
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5363   float arg2 ;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   arg2 = (float)jarg2;
5367   if (arg1) (arg1)->width = arg2;
5368 }
5369
5370
5371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5372   float jresult ;
5373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5374   float result;
5375
5376   arg1 = (Dali::Vector2 *)jarg1;
5377   result = (float) ((arg1)->width);
5378   jresult = result;
5379   return jresult;
5380 }
5381
5382
5383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5384   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5385   float arg2 ;
5386
5387   arg1 = (Dali::Vector2 *)jarg1;
5388   arg2 = (float)jarg2;
5389   if (arg1) (arg1)->y = arg2;
5390 }
5391
5392
5393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5394   float jresult ;
5395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5396   float result;
5397
5398   arg1 = (Dali::Vector2 *)jarg1;
5399   result = (float) ((arg1)->y);
5400   jresult = result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5406   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5407   float arg2 ;
5408
5409   arg1 = (Dali::Vector2 *)jarg1;
5410   arg2 = (float)jarg2;
5411   if (arg1) (arg1)->height = arg2;
5412 }
5413
5414
5415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5416   float jresult ;
5417   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5418   float result;
5419
5420   arg1 = (Dali::Vector2 *)jarg1;
5421   result = (float) ((arg1)->height);
5422   jresult = result;
5423   return jresult;
5424 }
5425
5426
5427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5429
5430   arg1 = (Dali::Vector2 *)jarg1;
5431   {
5432     try {
5433       delete arg1;
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5441       };
5442     } catch (Dali::DaliException e) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5445       };
5446     } catch (...) {
5447       {
5448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5449       };
5450     }
5451   }
5452
5453 }
5454
5455
5456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5457   void * jresult ;
5458   Dali::Vector2 *arg1 = 0 ;
5459   Dali::Vector2 *arg2 = 0 ;
5460   Dali::Vector2 result;
5461
5462   arg1 = (Dali::Vector2 *)jarg1;
5463   if (!arg1) {
5464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5465     return 0;
5466   }
5467   arg2 = (Dali::Vector2 *)jarg2;
5468   if (!arg2) {
5469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5470     return 0;
5471   }
5472   {
5473     try {
5474       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5475     } catch (std::out_of_range& e) {
5476       {
5477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (std::exception& e) {
5480       {
5481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5482       };
5483     } catch (Dali::DaliException e) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5486       };
5487     } catch (...) {
5488       {
5489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5490       };
5491     }
5492   }
5493
5494   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5495   return jresult;
5496 }
5497
5498
5499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5500   void * jresult ;
5501   Dali::Vector2 *arg1 = 0 ;
5502   Dali::Vector2 *arg2 = 0 ;
5503   Dali::Vector2 result;
5504
5505   arg1 = (Dali::Vector2 *)jarg1;
5506   if (!arg1) {
5507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5508     return 0;
5509   }
5510   arg2 = (Dali::Vector2 *)jarg2;
5511   if (!arg2) {
5512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5513     return 0;
5514   }
5515   {
5516     try {
5517       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5518     } catch (std::out_of_range& e) {
5519       {
5520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (std::exception& e) {
5523       {
5524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5525       };
5526     } catch (Dali::DaliException e) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5529       };
5530     } catch (...) {
5531       {
5532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5533       };
5534     }
5535   }
5536
5537   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5538   return jresult;
5539 }
5540
5541
5542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5543   void * jresult ;
5544   Dali::Vector2 *arg1 = 0 ;
5545   float *arg2 = 0 ;
5546   float *arg3 = 0 ;
5547   float temp2 ;
5548   float temp3 ;
5549   Dali::Vector2 result;
5550
5551   arg1 = (Dali::Vector2 *)jarg1;
5552   if (!arg1) {
5553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5554     return 0;
5555   }
5556   temp2 = (float)jarg2;
5557   arg2 = &temp2;
5558   temp3 = (float)jarg3;
5559   arg3 = &temp3;
5560   {
5561     try {
5562       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (Dali::DaliException e) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581
5582   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5588   void * jresult ;
5589   Dali::Vector3 *result = 0 ;
5590
5591   {
5592     try {
5593       result = (Dali::Vector3 *)new Dali::Vector3();
5594     } catch (std::out_of_range& e) {
5595       {
5596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5597       };
5598     } catch (std::exception& e) {
5599       {
5600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5601       };
5602     } catch (Dali::DaliException e) {
5603       {
5604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5605       };
5606     } catch (...) {
5607       {
5608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5609       };
5610     }
5611   }
5612
5613   jresult = (void *)result;
5614   return jresult;
5615 }
5616
5617
5618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5619   void * jresult ;
5620   float arg1 ;
5621   float arg2 ;
5622   float arg3 ;
5623   Dali::Vector3 *result = 0 ;
5624
5625   arg1 = (float)jarg1;
5626   arg2 = (float)jarg2;
5627   arg3 = (float)jarg3;
5628   {
5629     try {
5630       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5631     } catch (std::out_of_range& e) {
5632       {
5633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (std::exception& e) {
5636       {
5637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5638       };
5639     } catch (Dali::DaliException e) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5642       };
5643     } catch (...) {
5644       {
5645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5646       };
5647     }
5648   }
5649
5650   jresult = (void *)result;
5651   return jresult;
5652 }
5653
5654
5655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5656   void * jresult ;
5657   float *arg1 = (float *) 0 ;
5658   Dali::Vector3 *result = 0 ;
5659
5660   arg1 = jarg1;
5661   {
5662     try {
5663       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5664     } catch (std::out_of_range& e) {
5665       {
5666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (std::exception& e) {
5669       {
5670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5671       };
5672     } catch (Dali::DaliException e) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5675       };
5676     } catch (...) {
5677       {
5678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5679       };
5680     }
5681   }
5682
5683   jresult = (void *)result;
5684
5685
5686   return jresult;
5687 }
5688
5689
5690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5691   void * jresult ;
5692   Dali::Vector2 *arg1 = 0 ;
5693   Dali::Vector3 *result = 0 ;
5694
5695   arg1 = (Dali::Vector2 *)jarg1;
5696   if (!arg1) {
5697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5698     return 0;
5699   }
5700   {
5701     try {
5702       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5703     } catch (std::out_of_range& e) {
5704       {
5705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5706       };
5707     } catch (std::exception& e) {
5708       {
5709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5710       };
5711     } catch (Dali::DaliException e) {
5712       {
5713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5714       };
5715     } catch (...) {
5716       {
5717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5718       };
5719     }
5720   }
5721
5722   jresult = (void *)result;
5723   return jresult;
5724 }
5725
5726
5727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5728   void * jresult ;
5729   Dali::Vector4 *arg1 = 0 ;
5730   Dali::Vector3 *result = 0 ;
5731
5732   arg1 = (Dali::Vector4 *)jarg1;
5733   if (!arg1) {
5734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5735     return 0;
5736   }
5737   {
5738     try {
5739       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5740     } catch (std::out_of_range& e) {
5741       {
5742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5743       };
5744     } catch (std::exception& e) {
5745       {
5746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5747       };
5748     } catch (Dali::DaliException e) {
5749       {
5750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5751       };
5752     } catch (...) {
5753       {
5754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5755       };
5756     }
5757   }
5758
5759   jresult = (void *)result;
5760   return jresult;
5761 }
5762
5763
5764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5765   void * jresult ;
5766   Dali::Vector3 *result = 0 ;
5767
5768   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5769   jresult = (void *)result;
5770   return jresult;
5771 }
5772
5773
5774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5775   void * jresult ;
5776   Dali::Vector3 *result = 0 ;
5777
5778   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5779   jresult = (void *)result;
5780   return jresult;
5781 }
5782
5783
5784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5785   void * jresult ;
5786   Dali::Vector3 *result = 0 ;
5787
5788   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5789   jresult = (void *)result;
5790   return jresult;
5791 }
5792
5793
5794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5795   void * jresult ;
5796   Dali::Vector3 *result = 0 ;
5797
5798   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5799   jresult = (void *)result;
5800   return jresult;
5801 }
5802
5803
5804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5805   void * jresult ;
5806   Dali::Vector3 *result = 0 ;
5807
5808   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5809   jresult = (void *)result;
5810   return jresult;
5811 }
5812
5813
5814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5815   void * jresult ;
5816   Dali::Vector3 *result = 0 ;
5817
5818   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5819   jresult = (void *)result;
5820   return jresult;
5821 }
5822
5823
5824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5825   void * jresult ;
5826   Dali::Vector3 *result = 0 ;
5827
5828   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5829   jresult = (void *)result;
5830   return jresult;
5831 }
5832
5833
5834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5835   void * jresult ;
5836   Dali::Vector3 *result = 0 ;
5837
5838   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5839   jresult = (void *)result;
5840   return jresult;
5841 }
5842
5843
5844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5845   void * jresult ;
5846   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5847   float *arg2 = (float *) 0 ;
5848   Dali::Vector3 *result = 0 ;
5849
5850   arg1 = (Dali::Vector3 *)jarg1;
5851   arg2 = jarg2;
5852   {
5853     try {
5854       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5855     } catch (std::out_of_range& e) {
5856       {
5857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (std::exception& e) {
5860       {
5861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5862       };
5863     } catch (Dali::DaliException e) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5866       };
5867     } catch (...) {
5868       {
5869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5870       };
5871     }
5872   }
5873
5874   jresult = (void *)result;
5875
5876
5877   return jresult;
5878 }
5879
5880
5881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5882   void * jresult ;
5883   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5884   Dali::Vector2 *arg2 = 0 ;
5885   Dali::Vector3 *result = 0 ;
5886
5887   arg1 = (Dali::Vector3 *)jarg1;
5888   arg2 = (Dali::Vector2 *)jarg2;
5889   if (!arg2) {
5890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5891     return 0;
5892   }
5893   {
5894     try {
5895       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5896     } catch (std::out_of_range& e) {
5897       {
5898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5899       };
5900     } catch (std::exception& e) {
5901       {
5902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5903       };
5904     } catch (Dali::DaliException e) {
5905       {
5906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5907       };
5908     } catch (...) {
5909       {
5910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5911       };
5912     }
5913   }
5914
5915   jresult = (void *)result;
5916   return jresult;
5917 }
5918
5919
5920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5921   void * jresult ;
5922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5923   Dali::Vector4 *arg2 = 0 ;
5924   Dali::Vector3 *result = 0 ;
5925
5926   arg1 = (Dali::Vector3 *)jarg1;
5927   arg2 = (Dali::Vector4 *)jarg2;
5928   if (!arg2) {
5929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5930     return 0;
5931   }
5932   {
5933     try {
5934       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5935     } catch (std::out_of_range& e) {
5936       {
5937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5938       };
5939     } catch (std::exception& e) {
5940       {
5941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5942       };
5943     } catch (Dali::DaliException e) {
5944       {
5945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5946       };
5947     } catch (...) {
5948       {
5949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5950       };
5951     }
5952   }
5953
5954   jresult = (void *)result;
5955   return jresult;
5956 }
5957
5958
5959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5960   void * jresult ;
5961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5962   Dali::Vector3 *arg2 = 0 ;
5963   Dali::Vector3 result;
5964
5965   arg1 = (Dali::Vector3 *)jarg1;
5966   arg2 = (Dali::Vector3 *)jarg2;
5967   if (!arg2) {
5968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5969     return 0;
5970   }
5971   {
5972     try {
5973       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5974     } catch (std::out_of_range& e) {
5975       {
5976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5977       };
5978     } catch (std::exception& e) {
5979       {
5980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5981       };
5982     } catch (Dali::DaliException e) {
5983       {
5984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5985       };
5986     } catch (...) {
5987       {
5988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5989       };
5990     }
5991   }
5992
5993   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5994   return jresult;
5995 }
5996
5997
5998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5999   void * jresult ;
6000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6001   Dali::Vector3 *arg2 = 0 ;
6002   Dali::Vector3 *result = 0 ;
6003
6004   arg1 = (Dali::Vector3 *)jarg1;
6005   arg2 = (Dali::Vector3 *)jarg2;
6006   if (!arg2) {
6007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6008     return 0;
6009   }
6010   {
6011     try {
6012       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6013     } catch (std::out_of_range& e) {
6014       {
6015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6016       };
6017     } catch (std::exception& e) {
6018       {
6019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6020       };
6021     } catch (Dali::DaliException e) {
6022       {
6023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6024       };
6025     } catch (...) {
6026       {
6027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6028       };
6029     }
6030   }
6031
6032   jresult = (void *)result;
6033   return jresult;
6034 }
6035
6036
6037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6038   void * jresult ;
6039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6040   Dali::Vector3 *arg2 = 0 ;
6041   Dali::Vector3 result;
6042
6043   arg1 = (Dali::Vector3 *)jarg1;
6044   arg2 = (Dali::Vector3 *)jarg2;
6045   if (!arg2) {
6046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6047     return 0;
6048   }
6049   {
6050     try {
6051       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6052     } catch (std::out_of_range& e) {
6053       {
6054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (std::exception& e) {
6057       {
6058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6059       };
6060     } catch (Dali::DaliException e) {
6061       {
6062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6063       };
6064     } catch (...) {
6065       {
6066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6067       };
6068     }
6069   }
6070
6071   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6072   return jresult;
6073 }
6074
6075
6076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6077   void * jresult ;
6078   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6079   Dali::Vector3 *arg2 = 0 ;
6080   Dali::Vector3 *result = 0 ;
6081
6082   arg1 = (Dali::Vector3 *)jarg1;
6083   arg2 = (Dali::Vector3 *)jarg2;
6084   if (!arg2) {
6085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6086     return 0;
6087   }
6088   {
6089     try {
6090       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6091     } catch (std::out_of_range& e) {
6092       {
6093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (std::exception& e) {
6096       {
6097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6098       };
6099     } catch (Dali::DaliException e) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6102       };
6103     } catch (...) {
6104       {
6105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6106       };
6107     }
6108   }
6109
6110   jresult = (void *)result;
6111   return jresult;
6112 }
6113
6114
6115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6116   void * jresult ;
6117   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6118   Dali::Vector3 *arg2 = 0 ;
6119   Dali::Vector3 result;
6120
6121   arg1 = (Dali::Vector3 *)jarg1;
6122   arg2 = (Dali::Vector3 *)jarg2;
6123   if (!arg2) {
6124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6125     return 0;
6126   }
6127   {
6128     try {
6129       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6130     } catch (std::out_of_range& e) {
6131       {
6132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6133       };
6134     } catch (std::exception& e) {
6135       {
6136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6137       };
6138     } catch (Dali::DaliException e) {
6139       {
6140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6141       };
6142     } catch (...) {
6143       {
6144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6145       };
6146     }
6147   }
6148
6149   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6150   return jresult;
6151 }
6152
6153
6154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6155   void * jresult ;
6156   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6157   float arg2 ;
6158   Dali::Vector3 result;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   arg2 = (float)jarg2;
6162   {
6163     try {
6164       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6165     } catch (std::out_of_range& e) {
6166       {
6167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6168       };
6169     } catch (std::exception& e) {
6170       {
6171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6172       };
6173     } catch (Dali::DaliException e) {
6174       {
6175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6176       };
6177     } catch (...) {
6178       {
6179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6180       };
6181     }
6182   }
6183
6184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6185   return jresult;
6186 }
6187
6188
6189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6190   void * jresult ;
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   Dali::Vector3 *arg2 = 0 ;
6193   Dali::Vector3 *result = 0 ;
6194
6195   arg1 = (Dali::Vector3 *)jarg1;
6196   arg2 = (Dali::Vector3 *)jarg2;
6197   if (!arg2) {
6198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6199     return 0;
6200   }
6201   {
6202     try {
6203       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6204     } catch (std::out_of_range& e) {
6205       {
6206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (std::exception& e) {
6209       {
6210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6211       };
6212     } catch (Dali::DaliException e) {
6213       {
6214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6215       };
6216     } catch (...) {
6217       {
6218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6219       };
6220     }
6221   }
6222
6223   jresult = (void *)result;
6224   return jresult;
6225 }
6226
6227
6228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6229   void * jresult ;
6230   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6231   float arg2 ;
6232   Dali::Vector3 *result = 0 ;
6233
6234   arg1 = (Dali::Vector3 *)jarg1;
6235   arg2 = (float)jarg2;
6236   {
6237     try {
6238       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6239     } catch (std::out_of_range& e) {
6240       {
6241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6242       };
6243     } catch (std::exception& e) {
6244       {
6245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6246       };
6247     } catch (Dali::DaliException e) {
6248       {
6249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6250       };
6251     } catch (...) {
6252       {
6253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6254       };
6255     }
6256   }
6257
6258   jresult = (void *)result;
6259   return jresult;
6260 }
6261
6262
6263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6264   void * jresult ;
6265   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6266   Dali::Quaternion *arg2 = 0 ;
6267   Dali::Vector3 *result = 0 ;
6268
6269   arg1 = (Dali::Vector3 *)jarg1;
6270   arg2 = (Dali::Quaternion *)jarg2;
6271   if (!arg2) {
6272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6273     return 0;
6274   }
6275   {
6276     try {
6277       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6278     } catch (std::out_of_range& e) {
6279       {
6280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6281       };
6282     } catch (std::exception& e) {
6283       {
6284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6285       };
6286     } catch (Dali::DaliException e) {
6287       {
6288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6289       };
6290     } catch (...) {
6291       {
6292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6293       };
6294     }
6295   }
6296
6297   jresult = (void *)result;
6298   return jresult;
6299 }
6300
6301
6302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6303   void * jresult ;
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   Dali::Vector3 *arg2 = 0 ;
6306   Dali::Vector3 result;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   arg2 = (Dali::Vector3 *)jarg2;
6310   if (!arg2) {
6311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6312     return 0;
6313   }
6314   {
6315     try {
6316       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6317     } catch (std::out_of_range& e) {
6318       {
6319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6320       };
6321     } catch (std::exception& e) {
6322       {
6323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6324       };
6325     } catch (Dali::DaliException e) {
6326       {
6327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6328       };
6329     } catch (...) {
6330       {
6331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6332       };
6333     }
6334   }
6335
6336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6337   return jresult;
6338 }
6339
6340
6341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6342   void * jresult ;
6343   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6344   float arg2 ;
6345   Dali::Vector3 result;
6346
6347   arg1 = (Dali::Vector3 *)jarg1;
6348   arg2 = (float)jarg2;
6349   {
6350     try {
6351       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6352     } catch (std::out_of_range& e) {
6353       {
6354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6355       };
6356     } catch (std::exception& e) {
6357       {
6358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6359       };
6360     } catch (Dali::DaliException e) {
6361       {
6362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6363       };
6364     } catch (...) {
6365       {
6366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6367       };
6368     }
6369   }
6370
6371   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6372   return jresult;
6373 }
6374
6375
6376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6377   void * jresult ;
6378   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6379   Dali::Vector3 *arg2 = 0 ;
6380   Dali::Vector3 *result = 0 ;
6381
6382   arg1 = (Dali::Vector3 *)jarg1;
6383   arg2 = (Dali::Vector3 *)jarg2;
6384   if (!arg2) {
6385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6386     return 0;
6387   }
6388   {
6389     try {
6390       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6391     } catch (std::out_of_range& e) {
6392       {
6393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6394       };
6395     } catch (std::exception& e) {
6396       {
6397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6398       };
6399     } catch (Dali::DaliException e) {
6400       {
6401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6402       };
6403     } catch (...) {
6404       {
6405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6406       };
6407     }
6408   }
6409
6410   jresult = (void *)result;
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6416   void * jresult ;
6417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6418   float arg2 ;
6419   Dali::Vector3 *result = 0 ;
6420
6421   arg1 = (Dali::Vector3 *)jarg1;
6422   arg2 = (float)jarg2;
6423   {
6424     try {
6425       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6426     } catch (std::out_of_range& e) {
6427       {
6428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6429       };
6430     } catch (std::exception& e) {
6431       {
6432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6433       };
6434     } catch (Dali::DaliException e) {
6435       {
6436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6437       };
6438     } catch (...) {
6439       {
6440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6441       };
6442     }
6443   }
6444
6445   jresult = (void *)result;
6446   return jresult;
6447 }
6448
6449
6450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6451   void * jresult ;
6452   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6453   Dali::Vector3 result;
6454
6455   arg1 = (Dali::Vector3 *)jarg1;
6456   {
6457     try {
6458       result = ((Dali::Vector3 const *)arg1)->operator -();
6459     } catch (std::out_of_range& e) {
6460       {
6461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6462       };
6463     } catch (std::exception& e) {
6464       {
6465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6466       };
6467     } catch (Dali::DaliException e) {
6468       {
6469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6470       };
6471     } catch (...) {
6472       {
6473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6474       };
6475     }
6476   }
6477
6478   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6479   return jresult;
6480 }
6481
6482
6483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6484   unsigned int jresult ;
6485   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6486   Dali::Vector3 *arg2 = 0 ;
6487   bool result;
6488
6489   arg1 = (Dali::Vector3 *)jarg1;
6490   arg2 = (Dali::Vector3 *)jarg2;
6491   if (!arg2) {
6492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6493     return 0;
6494   }
6495   {
6496     try {
6497       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6498     } catch (std::out_of_range& e) {
6499       {
6500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (std::exception& e) {
6503       {
6504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (Dali::DaliException e) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6509       };
6510     } catch (...) {
6511       {
6512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6513       };
6514     }
6515   }
6516
6517   jresult = result;
6518   return jresult;
6519 }
6520
6521
6522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6523   unsigned int jresult ;
6524   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6525   Dali::Vector3 *arg2 = 0 ;
6526   bool result;
6527
6528   arg1 = (Dali::Vector3 *)jarg1;
6529   arg2 = (Dali::Vector3 *)jarg2;
6530   if (!arg2) {
6531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6532     return 0;
6533   }
6534   {
6535     try {
6536       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6537     } catch (std::out_of_range& e) {
6538       {
6539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6540       };
6541     } catch (std::exception& e) {
6542       {
6543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6544       };
6545     } catch (Dali::DaliException e) {
6546       {
6547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6548       };
6549     } catch (...) {
6550       {
6551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6552       };
6553     }
6554   }
6555
6556   jresult = result;
6557   return jresult;
6558 }
6559
6560
6561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6562   float jresult ;
6563   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6564   unsigned int arg2 ;
6565   float *result = 0 ;
6566
6567   arg1 = (Dali::Vector3 *)jarg1;
6568   arg2 = (unsigned int)jarg2;
6569   {
6570     try {
6571       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6572     } catch (std::out_of_range& e) {
6573       {
6574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6575       };
6576     } catch (std::exception& e) {
6577       {
6578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6579       };
6580     } catch (Dali::DaliException e) {
6581       {
6582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6583       };
6584     } catch (...) {
6585       {
6586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6587       };
6588     }
6589   }
6590
6591   jresult = *result;
6592   return jresult;
6593 }
6594
6595
6596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6597   float jresult ;
6598   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6599   Dali::Vector3 *arg2 = 0 ;
6600   float result;
6601
6602   arg1 = (Dali::Vector3 *)jarg1;
6603   arg2 = (Dali::Vector3 *)jarg2;
6604   if (!arg2) {
6605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6606     return 0;
6607   }
6608   {
6609     try {
6610       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6611     } catch (std::out_of_range& e) {
6612       {
6613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (std::exception& e) {
6616       {
6617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (Dali::DaliException e) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6622       };
6623     } catch (...) {
6624       {
6625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6626       };
6627     }
6628   }
6629
6630   jresult = result;
6631   return jresult;
6632 }
6633
6634
6635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6636   void * jresult ;
6637   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6638   Dali::Vector3 *arg2 = 0 ;
6639   Dali::Vector3 result;
6640
6641   arg1 = (Dali::Vector3 *)jarg1;
6642   arg2 = (Dali::Vector3 *)jarg2;
6643   if (!arg2) {
6644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6645     return 0;
6646   }
6647   {
6648     try {
6649       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6650     } catch (std::out_of_range& e) {
6651       {
6652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (std::exception& e) {
6655       {
6656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6657       };
6658     } catch (Dali::DaliException e) {
6659       {
6660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6661       };
6662     } catch (...) {
6663       {
6664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6665       };
6666     }
6667   }
6668
6669   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6670   return jresult;
6671 }
6672
6673
6674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6675   float jresult ;
6676   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6677   float result;
6678
6679   arg1 = (Dali::Vector3 *)jarg1;
6680   {
6681     try {
6682       result = (float)((Dali::Vector3 const *)arg1)->Length();
6683     } catch (std::out_of_range& e) {
6684       {
6685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (std::exception& e) {
6688       {
6689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6690       };
6691     } catch (Dali::DaliException e) {
6692       {
6693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6694       };
6695     } catch (...) {
6696       {
6697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6698       };
6699     }
6700   }
6701
6702   jresult = result;
6703   return jresult;
6704 }
6705
6706
6707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6708   float jresult ;
6709   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6710   float result;
6711
6712   arg1 = (Dali::Vector3 *)jarg1;
6713   {
6714     try {
6715       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6716     } catch (std::out_of_range& e) {
6717       {
6718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (std::exception& e) {
6721       {
6722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6723       };
6724     } catch (Dali::DaliException e) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6727       };
6728     } catch (...) {
6729       {
6730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6731       };
6732     }
6733   }
6734
6735   jresult = result;
6736   return jresult;
6737 }
6738
6739
6740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6741   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6742
6743   arg1 = (Dali::Vector3 *)jarg1;
6744   {
6745     try {
6746       (arg1)->Normalize();
6747     } catch (std::out_of_range& e) {
6748       {
6749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (std::exception& e) {
6752       {
6753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6754       };
6755     } catch (Dali::DaliException e) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6758       };
6759     } catch (...) {
6760       {
6761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6762       };
6763     }
6764   }
6765
6766 }
6767
6768
6769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6770   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6771   Dali::Vector3 *arg2 = 0 ;
6772   Dali::Vector3 *arg3 = 0 ;
6773
6774   arg1 = (Dali::Vector3 *)jarg1;
6775   arg2 = (Dali::Vector3 *)jarg2;
6776   if (!arg2) {
6777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6778     return ;
6779   }
6780   arg3 = (Dali::Vector3 *)jarg3;
6781   if (!arg3) {
6782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6783     return ;
6784   }
6785   {
6786     try {
6787       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6788     } catch (std::out_of_range& e) {
6789       {
6790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6791       };
6792     } catch (std::exception& e) {
6793       {
6794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6795       };
6796     } catch (Dali::DaliException e) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6803       };
6804     }
6805   }
6806
6807 }
6808
6809
6810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6811   void * jresult ;
6812   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6813   float *result = 0 ;
6814
6815   arg1 = (Dali::Vector3 *)jarg1;
6816   {
6817     try {
6818       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6819     } catch (std::out_of_range& e) {
6820       {
6821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (std::exception& e) {
6824       {
6825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6826       };
6827     } catch (Dali::DaliException e) {
6828       {
6829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6830       };
6831     } catch (...) {
6832       {
6833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6834       };
6835     }
6836   }
6837
6838   jresult = (void *)result;
6839   return jresult;
6840 }
6841
6842
6843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6844   void * jresult ;
6845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6846   Dali::Vector2 *result = 0 ;
6847
6848   arg1 = (Dali::Vector3 *)jarg1;
6849   {
6850     try {
6851       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6852     } catch (std::out_of_range& e) {
6853       {
6854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6855       };
6856     } catch (std::exception& e) {
6857       {
6858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6859       };
6860     } catch (Dali::DaliException e) {
6861       {
6862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6863       };
6864     } catch (...) {
6865       {
6866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6867       };
6868     }
6869   }
6870
6871   jresult = (void *)result;
6872   return jresult;
6873 }
6874
6875
6876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6877   void * jresult ;
6878   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6879   Dali::Vector2 *result = 0 ;
6880
6881   arg1 = (Dali::Vector3 *)jarg1;
6882   {
6883     try {
6884       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6885     } catch (std::out_of_range& e) {
6886       {
6887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (std::exception& e) {
6890       {
6891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6892       };
6893     } catch (Dali::DaliException e) {
6894       {
6895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6896       };
6897     } catch (...) {
6898       {
6899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6900       };
6901     }
6902   }
6903
6904   jresult = (void *)result;
6905   return jresult;
6906 }
6907
6908
6909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6910   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6911   float arg2 ;
6912
6913   arg1 = (Dali::Vector3 *)jarg1;
6914   arg2 = (float)jarg2;
6915   if (arg1) (arg1)->x = arg2;
6916 }
6917
6918
6919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6920   float jresult ;
6921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6922   float result;
6923
6924   arg1 = (Dali::Vector3 *)jarg1;
6925   result = (float) ((arg1)->x);
6926   jresult = result;
6927   return jresult;
6928 }
6929
6930
6931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6932   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6933   float arg2 ;
6934
6935   arg1 = (Dali::Vector3 *)jarg1;
6936   arg2 = (float)jarg2;
6937   if (arg1) (arg1)->width = arg2;
6938 }
6939
6940
6941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6942   float jresult ;
6943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6944   float result;
6945
6946   arg1 = (Dali::Vector3 *)jarg1;
6947   result = (float) ((arg1)->width);
6948   jresult = result;
6949   return jresult;
6950 }
6951
6952
6953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6955   float arg2 ;
6956
6957   arg1 = (Dali::Vector3 *)jarg1;
6958   arg2 = (float)jarg2;
6959   if (arg1) (arg1)->r = arg2;
6960 }
6961
6962
6963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6964   float jresult ;
6965   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6966   float result;
6967
6968   arg1 = (Dali::Vector3 *)jarg1;
6969   result = (float) ((arg1)->r);
6970   jresult = result;
6971   return jresult;
6972 }
6973
6974
6975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6977   float arg2 ;
6978
6979   arg1 = (Dali::Vector3 *)jarg1;
6980   arg2 = (float)jarg2;
6981   if (arg1) (arg1)->y = arg2;
6982 }
6983
6984
6985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6986   float jresult ;
6987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6988   float result;
6989
6990   arg1 = (Dali::Vector3 *)jarg1;
6991   result = (float) ((arg1)->y);
6992   jresult = result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6999   float arg2 ;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   arg2 = (float)jarg2;
7003   if (arg1) (arg1)->height = arg2;
7004 }
7005
7006
7007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7008   float jresult ;
7009   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7010   float result;
7011
7012   arg1 = (Dali::Vector3 *)jarg1;
7013   result = (float) ((arg1)->height);
7014   jresult = result;
7015   return jresult;
7016 }
7017
7018
7019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7021   float arg2 ;
7022
7023   arg1 = (Dali::Vector3 *)jarg1;
7024   arg2 = (float)jarg2;
7025   if (arg1) (arg1)->g = arg2;
7026 }
7027
7028
7029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7030   float jresult ;
7031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7032   float result;
7033
7034   arg1 = (Dali::Vector3 *)jarg1;
7035   result = (float) ((arg1)->g);
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7043   float arg2 ;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   arg2 = (float)jarg2;
7047   if (arg1) (arg1)->z = arg2;
7048 }
7049
7050
7051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7052   float jresult ;
7053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7054   float result;
7055
7056   arg1 = (Dali::Vector3 *)jarg1;
7057   result = (float) ((arg1)->z);
7058   jresult = result;
7059   return jresult;
7060 }
7061
7062
7063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7065   float arg2 ;
7066
7067   arg1 = (Dali::Vector3 *)jarg1;
7068   arg2 = (float)jarg2;
7069   if (arg1) (arg1)->depth = arg2;
7070 }
7071
7072
7073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7074   float jresult ;
7075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7076   float result;
7077
7078   arg1 = (Dali::Vector3 *)jarg1;
7079   result = (float) ((arg1)->depth);
7080   jresult = result;
7081   return jresult;
7082 }
7083
7084
7085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7087   float arg2 ;
7088
7089   arg1 = (Dali::Vector3 *)jarg1;
7090   arg2 = (float)jarg2;
7091   if (arg1) (arg1)->b = arg2;
7092 }
7093
7094
7095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7096   float jresult ;
7097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7098   float result;
7099
7100   arg1 = (Dali::Vector3 *)jarg1;
7101   result = (float) ((arg1)->b);
7102   jresult = result;
7103   return jresult;
7104 }
7105
7106
7107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7108   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7109
7110   arg1 = (Dali::Vector3 *)jarg1;
7111   {
7112     try {
7113       delete arg1;
7114     } catch (std::out_of_range& e) {
7115       {
7116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7117       };
7118     } catch (std::exception& e) {
7119       {
7120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7121       };
7122     } catch (Dali::DaliException e) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7125       };
7126     } catch (...) {
7127       {
7128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7129       };
7130     }
7131   }
7132
7133 }
7134
7135
7136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7137   void * jresult ;
7138   Dali::Vector3 *arg1 = 0 ;
7139   Dali::Vector3 *arg2 = 0 ;
7140   Dali::Vector3 result;
7141
7142   arg1 = (Dali::Vector3 *)jarg1;
7143   if (!arg1) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7145     return 0;
7146   }
7147   arg2 = (Dali::Vector3 *)jarg2;
7148   if (!arg2) {
7149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7150     return 0;
7151   }
7152   {
7153     try {
7154       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7155     } catch (std::out_of_range& e) {
7156       {
7157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (std::exception& e) {
7160       {
7161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7162       };
7163     } catch (Dali::DaliException e) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7166       };
7167     } catch (...) {
7168       {
7169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7170       };
7171     }
7172   }
7173
7174   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7175   return jresult;
7176 }
7177
7178
7179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7180   void * jresult ;
7181   Dali::Vector3 *arg1 = 0 ;
7182   Dali::Vector3 *arg2 = 0 ;
7183   Dali::Vector3 result;
7184
7185   arg1 = (Dali::Vector3 *)jarg1;
7186   if (!arg1) {
7187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7188     return 0;
7189   }
7190   arg2 = (Dali::Vector3 *)jarg2;
7191   if (!arg2) {
7192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7193     return 0;
7194   }
7195   {
7196     try {
7197       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (Dali::DaliException e) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7209       };
7210     } catch (...) {
7211       {
7212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7213       };
7214     }
7215   }
7216
7217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7218   return jresult;
7219 }
7220
7221
7222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7223   void * jresult ;
7224   Dali::Vector3 *arg1 = 0 ;
7225   float *arg2 = 0 ;
7226   float *arg3 = 0 ;
7227   float temp2 ;
7228   float temp3 ;
7229   Dali::Vector3 result;
7230
7231   arg1 = (Dali::Vector3 *)jarg1;
7232   if (!arg1) {
7233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7234     return 0;
7235   }
7236   temp2 = (float)jarg2;
7237   arg2 = &temp2;
7238   temp3 = (float)jarg3;
7239   arg3 = &temp3;
7240   {
7241     try {
7242       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7243     } catch (std::out_of_range& e) {
7244       {
7245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (std::exception& e) {
7248       {
7249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (Dali::DaliException e) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7254       };
7255     } catch (...) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7258       };
7259     }
7260   }
7261
7262   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7263   return jresult;
7264 }
7265
7266
7267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7268   void * jresult ;
7269   Dali::Vector4 *result = 0 ;
7270
7271   {
7272     try {
7273       result = (Dali::Vector4 *)new Dali::Vector4();
7274     } catch (std::out_of_range& e) {
7275       {
7276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7277       };
7278     } catch (std::exception& e) {
7279       {
7280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7281       };
7282     } catch (Dali::DaliException e) {
7283       {
7284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7285       };
7286     } catch (...) {
7287       {
7288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7289       };
7290     }
7291   }
7292
7293   jresult = (void *)result;
7294   return jresult;
7295 }
7296
7297
7298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7299   void * jresult ;
7300   float arg1 ;
7301   float arg2 ;
7302   float arg3 ;
7303   float arg4 ;
7304   Dali::Vector4 *result = 0 ;
7305
7306   arg1 = (float)jarg1;
7307   arg2 = (float)jarg2;
7308   arg3 = (float)jarg3;
7309   arg4 = (float)jarg4;
7310   {
7311     try {
7312       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7313     } catch (std::out_of_range& e) {
7314       {
7315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (std::exception& e) {
7318       {
7319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7320       };
7321     } catch (Dali::DaliException e) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7324       };
7325     } catch (...) {
7326       {
7327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7328       };
7329     }
7330   }
7331
7332   jresult = (void *)result;
7333   return jresult;
7334 }
7335
7336
7337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7338   void * jresult ;
7339   float *arg1 = (float *) 0 ;
7340   Dali::Vector4 *result = 0 ;
7341
7342   arg1 = jarg1;
7343   {
7344     try {
7345       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7346     } catch (std::out_of_range& e) {
7347       {
7348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (std::exception& e) {
7351       {
7352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (Dali::DaliException e) {
7355       {
7356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7357       };
7358     } catch (...) {
7359       {
7360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7361       };
7362     }
7363   }
7364
7365   jresult = (void *)result;
7366
7367
7368   return jresult;
7369 }
7370
7371
7372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7373   void * jresult ;
7374   Dali::Vector2 *arg1 = 0 ;
7375   Dali::Vector4 *result = 0 ;
7376
7377   arg1 = (Dali::Vector2 *)jarg1;
7378   if (!arg1) {
7379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7380     return 0;
7381   }
7382   {
7383     try {
7384       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7385     } catch (std::out_of_range& e) {
7386       {
7387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (std::exception& e) {
7390       {
7391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7392       };
7393     } catch (Dali::DaliException e) {
7394       {
7395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7396       };
7397     } catch (...) {
7398       {
7399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7400       };
7401     }
7402   }
7403
7404   jresult = (void *)result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7410   void * jresult ;
7411   Dali::Vector3 *arg1 = 0 ;
7412   Dali::Vector4 *result = 0 ;
7413
7414   arg1 = (Dali::Vector3 *)jarg1;
7415   if (!arg1) {
7416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7417     return 0;
7418   }
7419   {
7420     try {
7421       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7422     } catch (std::out_of_range& e) {
7423       {
7424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7425       };
7426     } catch (std::exception& e) {
7427       {
7428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7429       };
7430     } catch (Dali::DaliException e) {
7431       {
7432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7433       };
7434     } catch (...) {
7435       {
7436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7437       };
7438     }
7439   }
7440
7441   jresult = (void *)result;
7442   return jresult;
7443 }
7444
7445
7446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7447   void * jresult ;
7448   Dali::Vector4 *result = 0 ;
7449
7450   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7451   jresult = (void *)result;
7452   return jresult;
7453 }
7454
7455
7456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7457   void * jresult ;
7458   Dali::Vector4 *result = 0 ;
7459
7460   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7461   jresult = (void *)result;
7462   return jresult;
7463 }
7464
7465
7466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7467   void * jresult ;
7468   Dali::Vector4 *result = 0 ;
7469
7470   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7471   jresult = (void *)result;
7472   return jresult;
7473 }
7474
7475
7476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7477   void * jresult ;
7478   Dali::Vector4 *result = 0 ;
7479
7480   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7481   jresult = (void *)result;
7482   return jresult;
7483 }
7484
7485
7486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7487   void * jresult ;
7488   Dali::Vector4 *result = 0 ;
7489
7490   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7491   jresult = (void *)result;
7492   return jresult;
7493 }
7494
7495
7496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7497   void * jresult ;
7498   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7499   float *arg2 = (float *) 0 ;
7500   Dali::Vector4 *result = 0 ;
7501
7502   arg1 = (Dali::Vector4 *)jarg1;
7503   arg2 = jarg2;
7504   {
7505     try {
7506       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7507     } catch (std::out_of_range& e) {
7508       {
7509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (std::exception& e) {
7512       {
7513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7514       };
7515     } catch (Dali::DaliException e) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7518       };
7519     } catch (...) {
7520       {
7521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7522       };
7523     }
7524   }
7525
7526   jresult = (void *)result;
7527
7528
7529   return jresult;
7530 }
7531
7532
7533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7534   void * jresult ;
7535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7536   Dali::Vector2 *arg2 = 0 ;
7537   Dali::Vector4 *result = 0 ;
7538
7539   arg1 = (Dali::Vector4 *)jarg1;
7540   arg2 = (Dali::Vector2 *)jarg2;
7541   if (!arg2) {
7542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7543     return 0;
7544   }
7545   {
7546     try {
7547       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7548     } catch (std::out_of_range& e) {
7549       {
7550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (std::exception& e) {
7553       {
7554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7555       };
7556     } catch (Dali::DaliException e) {
7557       {
7558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7559       };
7560     } catch (...) {
7561       {
7562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7563       };
7564     }
7565   }
7566
7567   jresult = (void *)result;
7568   return jresult;
7569 }
7570
7571
7572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7573   void * jresult ;
7574   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7575   Dali::Vector3 *arg2 = 0 ;
7576   Dali::Vector4 *result = 0 ;
7577
7578   arg1 = (Dali::Vector4 *)jarg1;
7579   arg2 = (Dali::Vector3 *)jarg2;
7580   if (!arg2) {
7581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7582     return 0;
7583   }
7584   {
7585     try {
7586       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7587     } catch (std::out_of_range& e) {
7588       {
7589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7590       };
7591     } catch (std::exception& e) {
7592       {
7593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7594       };
7595     } catch (Dali::DaliException e) {
7596       {
7597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7598       };
7599     } catch (...) {
7600       {
7601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7602       };
7603     }
7604   }
7605
7606   jresult = (void *)result;
7607   return jresult;
7608 }
7609
7610
7611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7612   void * jresult ;
7613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7614   Dali::Vector4 *arg2 = 0 ;
7615   Dali::Vector4 result;
7616
7617   arg1 = (Dali::Vector4 *)jarg1;
7618   arg2 = (Dali::Vector4 *)jarg2;
7619   if (!arg2) {
7620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7621     return 0;
7622   }
7623   {
7624     try {
7625       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7626     } catch (std::out_of_range& e) {
7627       {
7628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7629       };
7630     } catch (std::exception& e) {
7631       {
7632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7633       };
7634     } catch (Dali::DaliException e) {
7635       {
7636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7637       };
7638     } catch (...) {
7639       {
7640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7641       };
7642     }
7643   }
7644
7645   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7646   return jresult;
7647 }
7648
7649
7650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7651   void * jresult ;
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   Dali::Vector4 *arg2 = 0 ;
7654   Dali::Vector4 *result = 0 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   arg2 = (Dali::Vector4 *)jarg2;
7658   if (!arg2) {
7659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7660     return 0;
7661   }
7662   {
7663     try {
7664       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7665     } catch (std::out_of_range& e) {
7666       {
7667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7668       };
7669     } catch (std::exception& e) {
7670       {
7671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7672       };
7673     } catch (Dali::DaliException e) {
7674       {
7675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7676       };
7677     } catch (...) {
7678       {
7679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7680       };
7681     }
7682   }
7683
7684   jresult = (void *)result;
7685   return jresult;
7686 }
7687
7688
7689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7690   void * jresult ;
7691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7692   Dali::Vector4 *arg2 = 0 ;
7693   Dali::Vector4 result;
7694
7695   arg1 = (Dali::Vector4 *)jarg1;
7696   arg2 = (Dali::Vector4 *)jarg2;
7697   if (!arg2) {
7698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7699     return 0;
7700   }
7701   {
7702     try {
7703       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7704     } catch (std::out_of_range& e) {
7705       {
7706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7707       };
7708     } catch (std::exception& e) {
7709       {
7710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7711       };
7712     } catch (Dali::DaliException e) {
7713       {
7714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7715       };
7716     } catch (...) {
7717       {
7718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7719       };
7720     }
7721   }
7722
7723   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7724   return jresult;
7725 }
7726
7727
7728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7729   void * jresult ;
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   Dali::Vector4 *arg2 = 0 ;
7732   Dali::Vector4 *result = 0 ;
7733
7734   arg1 = (Dali::Vector4 *)jarg1;
7735   arg2 = (Dali::Vector4 *)jarg2;
7736   if (!arg2) {
7737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7738     return 0;
7739   }
7740   {
7741     try {
7742       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7743     } catch (std::out_of_range& e) {
7744       {
7745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7746       };
7747     } catch (std::exception& e) {
7748       {
7749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7750       };
7751     } catch (Dali::DaliException e) {
7752       {
7753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7754       };
7755     } catch (...) {
7756       {
7757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7758       };
7759     }
7760   }
7761
7762   jresult = (void *)result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7768   void * jresult ;
7769   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7770   Dali::Vector4 *arg2 = 0 ;
7771   Dali::Vector4 result;
7772
7773   arg1 = (Dali::Vector4 *)jarg1;
7774   arg2 = (Dali::Vector4 *)jarg2;
7775   if (!arg2) {
7776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7777     return 0;
7778   }
7779   {
7780     try {
7781       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7782     } catch (std::out_of_range& e) {
7783       {
7784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7785       };
7786     } catch (std::exception& e) {
7787       {
7788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7789       };
7790     } catch (Dali::DaliException e) {
7791       {
7792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7793       };
7794     } catch (...) {
7795       {
7796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7797       };
7798     }
7799   }
7800
7801   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7807   void * jresult ;
7808   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7809   float arg2 ;
7810   Dali::Vector4 result;
7811
7812   arg1 = (Dali::Vector4 *)jarg1;
7813   arg2 = (float)jarg2;
7814   {
7815     try {
7816       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7817     } catch (std::out_of_range& e) {
7818       {
7819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7820       };
7821     } catch (std::exception& e) {
7822       {
7823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7824       };
7825     } catch (Dali::DaliException e) {
7826       {
7827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7828       };
7829     } catch (...) {
7830       {
7831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7832       };
7833     }
7834   }
7835
7836   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7837   return jresult;
7838 }
7839
7840
7841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7842   void * jresult ;
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844   Dali::Vector4 *arg2 = 0 ;
7845   Dali::Vector4 *result = 0 ;
7846
7847   arg1 = (Dali::Vector4 *)jarg1;
7848   arg2 = (Dali::Vector4 *)jarg2;
7849   if (!arg2) {
7850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7851     return 0;
7852   }
7853   {
7854     try {
7855       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7856     } catch (std::out_of_range& e) {
7857       {
7858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7859       };
7860     } catch (std::exception& e) {
7861       {
7862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7863       };
7864     } catch (Dali::DaliException e) {
7865       {
7866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7867       };
7868     } catch (...) {
7869       {
7870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7871       };
7872     }
7873   }
7874
7875   jresult = (void *)result;
7876   return jresult;
7877 }
7878
7879
7880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7881   void * jresult ;
7882   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7883   float arg2 ;
7884   Dali::Vector4 *result = 0 ;
7885
7886   arg1 = (Dali::Vector4 *)jarg1;
7887   arg2 = (float)jarg2;
7888   {
7889     try {
7890       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7891     } catch (std::out_of_range& e) {
7892       {
7893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7894       };
7895     } catch (std::exception& e) {
7896       {
7897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7898       };
7899     } catch (Dali::DaliException e) {
7900       {
7901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7902       };
7903     } catch (...) {
7904       {
7905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7906       };
7907     }
7908   }
7909
7910   jresult = (void *)result;
7911   return jresult;
7912 }
7913
7914
7915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7916   void * jresult ;
7917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7918   Dali::Vector4 *arg2 = 0 ;
7919   Dali::Vector4 result;
7920
7921   arg1 = (Dali::Vector4 *)jarg1;
7922   arg2 = (Dali::Vector4 *)jarg2;
7923   if (!arg2) {
7924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7925     return 0;
7926   }
7927   {
7928     try {
7929       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7930     } catch (std::out_of_range& e) {
7931       {
7932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7933       };
7934     } catch (std::exception& e) {
7935       {
7936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7937       };
7938     } catch (Dali::DaliException e) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7941       };
7942     } catch (...) {
7943       {
7944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7945       };
7946     }
7947   }
7948
7949   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7950   return jresult;
7951 }
7952
7953
7954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7955   void * jresult ;
7956   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7957   float arg2 ;
7958   Dali::Vector4 result;
7959
7960   arg1 = (Dali::Vector4 *)jarg1;
7961   arg2 = (float)jarg2;
7962   {
7963     try {
7964       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7965     } catch (std::out_of_range& e) {
7966       {
7967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7968       };
7969     } catch (std::exception& e) {
7970       {
7971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7972       };
7973     } catch (Dali::DaliException e) {
7974       {
7975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7976       };
7977     } catch (...) {
7978       {
7979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7980       };
7981     }
7982   }
7983
7984   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7985   return jresult;
7986 }
7987
7988
7989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7990   void * jresult ;
7991   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7992   Dali::Vector4 *arg2 = 0 ;
7993   Dali::Vector4 *result = 0 ;
7994
7995   arg1 = (Dali::Vector4 *)jarg1;
7996   arg2 = (Dali::Vector4 *)jarg2;
7997   if (!arg2) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8004     } catch (std::out_of_range& e) {
8005       {
8006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (std::exception& e) {
8009       {
8010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (Dali::DaliException e) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8015       };
8016     } catch (...) {
8017       {
8018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8019       };
8020     }
8021   }
8022
8023   jresult = (void *)result;
8024   return jresult;
8025 }
8026
8027
8028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8029   void * jresult ;
8030   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8031   float arg2 ;
8032   Dali::Vector4 *result = 0 ;
8033
8034   arg1 = (Dali::Vector4 *)jarg1;
8035   arg2 = (float)jarg2;
8036   {
8037     try {
8038       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8039     } catch (std::out_of_range& e) {
8040       {
8041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8042       };
8043     } catch (std::exception& e) {
8044       {
8045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8046       };
8047     } catch (Dali::DaliException e) {
8048       {
8049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8050       };
8051     } catch (...) {
8052       {
8053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8054       };
8055     }
8056   }
8057
8058   jresult = (void *)result;
8059   return jresult;
8060 }
8061
8062
8063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8064   void * jresult ;
8065   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8066   Dali::Vector4 result;
8067
8068   arg1 = (Dali::Vector4 *)jarg1;
8069   {
8070     try {
8071       result = ((Dali::Vector4 const *)arg1)->operator -();
8072     } catch (std::out_of_range& e) {
8073       {
8074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8075       };
8076     } catch (std::exception& e) {
8077       {
8078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8079       };
8080     } catch (Dali::DaliException e) {
8081       {
8082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8083       };
8084     } catch (...) {
8085       {
8086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8087       };
8088     }
8089   }
8090
8091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8092   return jresult;
8093 }
8094
8095
8096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8097   unsigned int jresult ;
8098   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8099   Dali::Vector4 *arg2 = 0 ;
8100   bool result;
8101
8102   arg1 = (Dali::Vector4 *)jarg1;
8103   arg2 = (Dali::Vector4 *)jarg2;
8104   if (!arg2) {
8105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8106     return 0;
8107   }
8108   {
8109     try {
8110       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8111     } catch (std::out_of_range& e) {
8112       {
8113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8114       };
8115     } catch (std::exception& e) {
8116       {
8117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8118       };
8119     } catch (Dali::DaliException e) {
8120       {
8121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8122       };
8123     } catch (...) {
8124       {
8125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8126       };
8127     }
8128   }
8129
8130   jresult = result;
8131   return jresult;
8132 }
8133
8134
8135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8136   unsigned int jresult ;
8137   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8138   Dali::Vector4 *arg2 = 0 ;
8139   bool result;
8140
8141   arg1 = (Dali::Vector4 *)jarg1;
8142   arg2 = (Dali::Vector4 *)jarg2;
8143   if (!arg2) {
8144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8145     return 0;
8146   }
8147   {
8148     try {
8149       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8150     } catch (std::out_of_range& e) {
8151       {
8152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8153       };
8154     } catch (std::exception& e) {
8155       {
8156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8157       };
8158     } catch (Dali::DaliException e) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8161       };
8162     } catch (...) {
8163       {
8164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8165       };
8166     }
8167   }
8168
8169   jresult = result;
8170   return jresult;
8171 }
8172
8173
8174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8175   float jresult ;
8176   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8177   unsigned int arg2 ;
8178   float *result = 0 ;
8179
8180   arg1 = (Dali::Vector4 *)jarg1;
8181   arg2 = (unsigned int)jarg2;
8182   {
8183     try {
8184       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8185     } catch (std::out_of_range& e) {
8186       {
8187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8188       };
8189     } catch (std::exception& e) {
8190       {
8191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8192       };
8193     } catch (Dali::DaliException e) {
8194       {
8195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8196       };
8197     } catch (...) {
8198       {
8199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8200       };
8201     }
8202   }
8203
8204   jresult = *result;
8205   return jresult;
8206 }
8207
8208
8209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8210   float jresult ;
8211   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8212   Dali::Vector3 *arg2 = 0 ;
8213   float result;
8214
8215   arg1 = (Dali::Vector4 *)jarg1;
8216   arg2 = (Dali::Vector3 *)jarg2;
8217   if (!arg2) {
8218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8219     return 0;
8220   }
8221   {
8222     try {
8223       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8224     } catch (std::out_of_range& e) {
8225       {
8226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8227       };
8228     } catch (std::exception& e) {
8229       {
8230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8231       };
8232     } catch (Dali::DaliException e) {
8233       {
8234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8235       };
8236     } catch (...) {
8237       {
8238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8239       };
8240     }
8241   }
8242
8243   jresult = result;
8244   return jresult;
8245 }
8246
8247
8248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8249   float jresult ;
8250   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8251   Dali::Vector4 *arg2 = 0 ;
8252   float result;
8253
8254   arg1 = (Dali::Vector4 *)jarg1;
8255   arg2 = (Dali::Vector4 *)jarg2;
8256   if (!arg2) {
8257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8258     return 0;
8259   }
8260   {
8261     try {
8262       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8263     } catch (std::out_of_range& e) {
8264       {
8265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8266       };
8267     } catch (std::exception& e) {
8268       {
8269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8270       };
8271     } catch (Dali::DaliException e) {
8272       {
8273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8274       };
8275     } catch (...) {
8276       {
8277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8278       };
8279     }
8280   }
8281
8282   jresult = result;
8283   return jresult;
8284 }
8285
8286
8287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8288   float jresult ;
8289   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8290   Dali::Vector4 *arg2 = 0 ;
8291   float result;
8292
8293   arg1 = (Dali::Vector4 *)jarg1;
8294   arg2 = (Dali::Vector4 *)jarg2;
8295   if (!arg2) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8297     return 0;
8298   }
8299   {
8300     try {
8301       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8302     } catch (std::out_of_range& e) {
8303       {
8304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (std::exception& e) {
8307       {
8308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8309       };
8310     } catch (Dali::DaliException e) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8313       };
8314     } catch (...) {
8315       {
8316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8317       };
8318     }
8319   }
8320
8321   jresult = result;
8322   return jresult;
8323 }
8324
8325
8326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8327   void * jresult ;
8328   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8329   Dali::Vector4 *arg2 = 0 ;
8330   Dali::Vector4 result;
8331
8332   arg1 = (Dali::Vector4 *)jarg1;
8333   arg2 = (Dali::Vector4 *)jarg2;
8334   if (!arg2) {
8335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8336     return 0;
8337   }
8338   {
8339     try {
8340       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8341     } catch (std::out_of_range& e) {
8342       {
8343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8344       };
8345     } catch (std::exception& e) {
8346       {
8347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8348       };
8349     } catch (Dali::DaliException e) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8352       };
8353     } catch (...) {
8354       {
8355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8356       };
8357     }
8358   }
8359
8360   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8361   return jresult;
8362 }
8363
8364
8365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8366   float jresult ;
8367   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8368   float result;
8369
8370   arg1 = (Dali::Vector4 *)jarg1;
8371   {
8372     try {
8373       result = (float)((Dali::Vector4 const *)arg1)->Length();
8374     } catch (std::out_of_range& e) {
8375       {
8376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (std::exception& e) {
8379       {
8380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8381       };
8382     } catch (Dali::DaliException e) {
8383       {
8384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8385       };
8386     } catch (...) {
8387       {
8388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8389       };
8390     }
8391   }
8392
8393   jresult = result;
8394   return jresult;
8395 }
8396
8397
8398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8399   float jresult ;
8400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8401   float result;
8402
8403   arg1 = (Dali::Vector4 *)jarg1;
8404   {
8405     try {
8406       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8407     } catch (std::out_of_range& e) {
8408       {
8409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (std::exception& e) {
8412       {
8413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8414       };
8415     } catch (Dali::DaliException e) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8418       };
8419     } catch (...) {
8420       {
8421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8422       };
8423     }
8424   }
8425
8426   jresult = result;
8427   return jresult;
8428 }
8429
8430
8431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8432   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8433
8434   arg1 = (Dali::Vector4 *)jarg1;
8435   {
8436     try {
8437       (arg1)->Normalize();
8438     } catch (std::out_of_range& e) {
8439       {
8440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (std::exception& e) {
8443       {
8444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8445       };
8446     } catch (Dali::DaliException e) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8449       };
8450     } catch (...) {
8451       {
8452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8453       };
8454     }
8455   }
8456
8457 }
8458
8459
8460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8462   Dali::Vector4 *arg2 = 0 ;
8463   Dali::Vector4 *arg3 = 0 ;
8464
8465   arg1 = (Dali::Vector4 *)jarg1;
8466   arg2 = (Dali::Vector4 *)jarg2;
8467   if (!arg2) {
8468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8469     return ;
8470   }
8471   arg3 = (Dali::Vector4 *)jarg3;
8472   if (!arg3) {
8473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8474     return ;
8475   }
8476   {
8477     try {
8478       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8479     } catch (std::out_of_range& e) {
8480       {
8481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8482       };
8483     } catch (std::exception& e) {
8484       {
8485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8486       };
8487     } catch (Dali::DaliException e) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8490       };
8491     } catch (...) {
8492       {
8493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8494       };
8495     }
8496   }
8497
8498 }
8499
8500
8501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8502   void * jresult ;
8503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8504   float *result = 0 ;
8505
8506   arg1 = (Dali::Vector4 *)jarg1;
8507   {
8508     try {
8509       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8510     } catch (std::out_of_range& e) {
8511       {
8512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (std::exception& e) {
8515       {
8516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8517       };
8518     } catch (Dali::DaliException e) {
8519       {
8520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8521       };
8522     } catch (...) {
8523       {
8524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8525       };
8526     }
8527   }
8528
8529   jresult = (void *)result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8536   float arg2 ;
8537
8538   arg1 = (Dali::Vector4 *)jarg1;
8539   arg2 = (float)jarg2;
8540   if (arg1) (arg1)->x = arg2;
8541 }
8542
8543
8544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8545   float jresult ;
8546   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8547   float result;
8548
8549   arg1 = (Dali::Vector4 *)jarg1;
8550   result = (float) ((arg1)->x);
8551   jresult = result;
8552   return jresult;
8553 }
8554
8555
8556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8557   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8558   float arg2 ;
8559
8560   arg1 = (Dali::Vector4 *)jarg1;
8561   arg2 = (float)jarg2;
8562   if (arg1) (arg1)->r = arg2;
8563 }
8564
8565
8566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8567   float jresult ;
8568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8569   float result;
8570
8571   arg1 = (Dali::Vector4 *)jarg1;
8572   result = (float) ((arg1)->r);
8573   jresult = result;
8574   return jresult;
8575 }
8576
8577
8578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8580   float arg2 ;
8581
8582   arg1 = (Dali::Vector4 *)jarg1;
8583   arg2 = (float)jarg2;
8584   if (arg1) (arg1)->s = arg2;
8585 }
8586
8587
8588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8589   float jresult ;
8590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8591   float result;
8592
8593   arg1 = (Dali::Vector4 *)jarg1;
8594   result = (float) ((arg1)->s);
8595   jresult = result;
8596   return jresult;
8597 }
8598
8599
8600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8602   float arg2 ;
8603
8604   arg1 = (Dali::Vector4 *)jarg1;
8605   arg2 = (float)jarg2;
8606   if (arg1) (arg1)->y = arg2;
8607 }
8608
8609
8610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8611   float jresult ;
8612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8613   float result;
8614
8615   arg1 = (Dali::Vector4 *)jarg1;
8616   result = (float) ((arg1)->y);
8617   jresult = result;
8618   return jresult;
8619 }
8620
8621
8622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8624   float arg2 ;
8625
8626   arg1 = (Dali::Vector4 *)jarg1;
8627   arg2 = (float)jarg2;
8628   if (arg1) (arg1)->g = arg2;
8629 }
8630
8631
8632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8633   float jresult ;
8634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8635   float result;
8636
8637   arg1 = (Dali::Vector4 *)jarg1;
8638   result = (float) ((arg1)->g);
8639   jresult = result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8646   float arg2 ;
8647
8648   arg1 = (Dali::Vector4 *)jarg1;
8649   arg2 = (float)jarg2;
8650   if (arg1) (arg1)->t = arg2;
8651 }
8652
8653
8654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8655   float jresult ;
8656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8657   float result;
8658
8659   arg1 = (Dali::Vector4 *)jarg1;
8660   result = (float) ((arg1)->t);
8661   jresult = result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8668   float arg2 ;
8669
8670   arg1 = (Dali::Vector4 *)jarg1;
8671   arg2 = (float)jarg2;
8672   if (arg1) (arg1)->z = arg2;
8673 }
8674
8675
8676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8677   float jresult ;
8678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8679   float result;
8680
8681   arg1 = (Dali::Vector4 *)jarg1;
8682   result = (float) ((arg1)->z);
8683   jresult = result;
8684   return jresult;
8685 }
8686
8687
8688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8690   float arg2 ;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   arg2 = (float)jarg2;
8694   if (arg1) (arg1)->b = arg2;
8695 }
8696
8697
8698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8699   float jresult ;
8700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8701   float result;
8702
8703   arg1 = (Dali::Vector4 *)jarg1;
8704   result = (float) ((arg1)->b);
8705   jresult = result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8712   float arg2 ;
8713
8714   arg1 = (Dali::Vector4 *)jarg1;
8715   arg2 = (float)jarg2;
8716   if (arg1) (arg1)->p = arg2;
8717 }
8718
8719
8720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8721   float jresult ;
8722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8723   float result;
8724
8725   arg1 = (Dali::Vector4 *)jarg1;
8726   result = (float) ((arg1)->p);
8727   jresult = result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8734   float arg2 ;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   arg2 = (float)jarg2;
8738   if (arg1) (arg1)->w = arg2;
8739 }
8740
8741
8742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8743   float jresult ;
8744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8745   float result;
8746
8747   arg1 = (Dali::Vector4 *)jarg1;
8748   result = (float) ((arg1)->w);
8749   jresult = result;
8750   return jresult;
8751 }
8752
8753
8754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8756   float arg2 ;
8757
8758   arg1 = (Dali::Vector4 *)jarg1;
8759   arg2 = (float)jarg2;
8760   if (arg1) (arg1)->a = arg2;
8761 }
8762
8763
8764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8765   float jresult ;
8766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8767   float result;
8768
8769   arg1 = (Dali::Vector4 *)jarg1;
8770   result = (float) ((arg1)->a);
8771   jresult = result;
8772   return jresult;
8773 }
8774
8775
8776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8778   float arg2 ;
8779
8780   arg1 = (Dali::Vector4 *)jarg1;
8781   arg2 = (float)jarg2;
8782   if (arg1) (arg1)->q = arg2;
8783 }
8784
8785
8786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8787   float jresult ;
8788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8789   float result;
8790
8791   arg1 = (Dali::Vector4 *)jarg1;
8792   result = (float) ((arg1)->q);
8793   jresult = result;
8794   return jresult;
8795 }
8796
8797
8798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8800
8801   arg1 = (Dali::Vector4 *)jarg1;
8802   {
8803     try {
8804       delete arg1;
8805     } catch (std::out_of_range& e) {
8806       {
8807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8808       };
8809     } catch (std::exception& e) {
8810       {
8811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8812       };
8813     } catch (Dali::DaliException e) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8816       };
8817     } catch (...) {
8818       {
8819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8820       };
8821     }
8822   }
8823
8824 }
8825
8826
8827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8828   void * jresult ;
8829   Dali::Vector4 *arg1 = 0 ;
8830   Dali::Vector4 *arg2 = 0 ;
8831   Dali::Vector4 result;
8832
8833   arg1 = (Dali::Vector4 *)jarg1;
8834   if (!arg1) {
8835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8836     return 0;
8837   }
8838   arg2 = (Dali::Vector4 *)jarg2;
8839   if (!arg2) {
8840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8841     return 0;
8842   }
8843   {
8844     try {
8845       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8846     } catch (std::out_of_range& e) {
8847       {
8848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (std::exception& e) {
8851       {
8852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8853       };
8854     } catch (Dali::DaliException e) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8857       };
8858     } catch (...) {
8859       {
8860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8861       };
8862     }
8863   }
8864
8865   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8866   return jresult;
8867 }
8868
8869
8870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8871   void * jresult ;
8872   Dali::Vector4 *arg1 = 0 ;
8873   Dali::Vector4 *arg2 = 0 ;
8874   Dali::Vector4 result;
8875
8876   arg1 = (Dali::Vector4 *)jarg1;
8877   if (!arg1) {
8878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8879     return 0;
8880   }
8881   arg2 = (Dali::Vector4 *)jarg2;
8882   if (!arg2) {
8883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8884     return 0;
8885   }
8886   {
8887     try {
8888       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8889     } catch (std::out_of_range& e) {
8890       {
8891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (std::exception& e) {
8894       {
8895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8896       };
8897     } catch (Dali::DaliException e) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8900       };
8901     } catch (...) {
8902       {
8903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8904       };
8905     }
8906   }
8907
8908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8909   return jresult;
8910 }
8911
8912
8913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8914   void * jresult ;
8915   Dali::Vector4 *arg1 = 0 ;
8916   float *arg2 = 0 ;
8917   float *arg3 = 0 ;
8918   float temp2 ;
8919   float temp3 ;
8920   Dali::Vector4 result;
8921
8922   arg1 = (Dali::Vector4 *)jarg1;
8923   if (!arg1) {
8924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8925     return 0;
8926   }
8927   temp2 = (float)jarg2;
8928   arg2 = &temp2;
8929   temp3 = (float)jarg3;
8930   arg3 = &temp3;
8931   {
8932     try {
8933       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8934     } catch (std::out_of_range& e) {
8935       {
8936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (std::exception& e) {
8939       {
8940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8941       };
8942     } catch (Dali::DaliException e) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8945       };
8946     } catch (...) {
8947       {
8948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8949       };
8950     }
8951   }
8952
8953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8954   return jresult;
8955 }
8956
8957
8958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8959   void * jresult ;
8960   Dali::Uint16Pair *result = 0 ;
8961
8962   {
8963     try {
8964       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8965     } catch (std::out_of_range& e) {
8966       {
8967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (std::exception& e) {
8970       {
8971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (Dali::DaliException e) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8976       };
8977     } catch (...) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8980       };
8981     }
8982   }
8983
8984   jresult = (void *)result;
8985   return jresult;
8986 }
8987
8988
8989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8990   void * jresult ;
8991   uint32_t arg1 ;
8992   uint32_t arg2 ;
8993   Dali::Uint16Pair *result = 0 ;
8994
8995   arg1 = (uint32_t)jarg1;
8996   arg2 = (uint32_t)jarg2;
8997   {
8998     try {
8999       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9000     } catch (std::out_of_range& e) {
9001       {
9002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (std::exception& e) {
9005       {
9006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9007       };
9008     } catch (Dali::DaliException e) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9011       };
9012     } catch (...) {
9013       {
9014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9015       };
9016     }
9017   }
9018
9019   jresult = (void *)result;
9020   return jresult;
9021 }
9022
9023
9024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9025   void * jresult ;
9026   Dali::Uint16Pair *arg1 = 0 ;
9027   Dali::Uint16Pair *result = 0 ;
9028
9029   arg1 = (Dali::Uint16Pair *)jarg1;
9030   if (!arg1) {
9031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9032     return 0;
9033   }
9034   {
9035     try {
9036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9037     } catch (std::out_of_range& e) {
9038       {
9039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9040       };
9041     } catch (std::exception& e) {
9042       {
9043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9044       };
9045     } catch (Dali::DaliException e) {
9046       {
9047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9048       };
9049     } catch (...) {
9050       {
9051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9052       };
9053     }
9054   }
9055
9056   jresult = (void *)result;
9057   return jresult;
9058 }
9059
9060
9061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9062   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9063   uint16_t arg2 ;
9064
9065   arg1 = (Dali::Uint16Pair *)jarg1;
9066   arg2 = (uint16_t)jarg2;
9067   {
9068     try {
9069       (arg1)->SetWidth(arg2);
9070     } catch (std::out_of_range& e) {
9071       {
9072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9073       };
9074     } catch (std::exception& e) {
9075       {
9076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9077       };
9078     } catch (Dali::DaliException e) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9081       };
9082     } catch (...) {
9083       {
9084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9085       };
9086     }
9087   }
9088
9089 }
9090
9091
9092 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9093   unsigned short jresult ;
9094   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9095   uint16_t result;
9096
9097   arg1 = (Dali::Uint16Pair *)jarg1;
9098   {
9099     try {
9100       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9101     } catch (std::out_of_range& e) {
9102       {
9103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9104       };
9105     } catch (std::exception& e) {
9106       {
9107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9108       };
9109     } catch (Dali::DaliException e) {
9110       {
9111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9112       };
9113     } catch (...) {
9114       {
9115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9116       };
9117     }
9118   }
9119
9120   jresult = result;
9121   return jresult;
9122 }
9123
9124
9125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9126   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9127   uint16_t arg2 ;
9128
9129   arg1 = (Dali::Uint16Pair *)jarg1;
9130   arg2 = (uint16_t)jarg2;
9131   {
9132     try {
9133       (arg1)->SetHeight(arg2);
9134     } catch (std::out_of_range& e) {
9135       {
9136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9137       };
9138     } catch (std::exception& e) {
9139       {
9140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9141       };
9142     } catch (Dali::DaliException e) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9145       };
9146     } catch (...) {
9147       {
9148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9149       };
9150     }
9151   }
9152
9153 }
9154
9155
9156 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9157   unsigned short jresult ;
9158   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9159   uint16_t result;
9160
9161   arg1 = (Dali::Uint16Pair *)jarg1;
9162   {
9163     try {
9164       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9165     } catch (std::out_of_range& e) {
9166       {
9167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9168       };
9169     } catch (std::exception& e) {
9170       {
9171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9172       };
9173     } catch (Dali::DaliException e) {
9174       {
9175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9176       };
9177     } catch (...) {
9178       {
9179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9180       };
9181     }
9182   }
9183
9184   jresult = result;
9185   return jresult;
9186 }
9187
9188
9189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9190   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9191   uint16_t arg2 ;
9192
9193   arg1 = (Dali::Uint16Pair *)jarg1;
9194   arg2 = (uint16_t)jarg2;
9195   {
9196     try {
9197       (arg1)->SetX(arg2);
9198     } catch (std::out_of_range& e) {
9199       {
9200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9201       };
9202     } catch (std::exception& e) {
9203       {
9204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9205       };
9206     } catch (Dali::DaliException e) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9209       };
9210     } catch (...) {
9211       {
9212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9213       };
9214     }
9215   }
9216
9217 }
9218
9219
9220 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9221   unsigned short jresult ;
9222   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9223   uint16_t result;
9224
9225   arg1 = (Dali::Uint16Pair *)jarg1;
9226   {
9227     try {
9228       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9229     } catch (std::out_of_range& e) {
9230       {
9231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (std::exception& e) {
9234       {
9235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9236       };
9237     } catch (Dali::DaliException e) {
9238       {
9239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9240       };
9241     } catch (...) {
9242       {
9243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9244       };
9245     }
9246   }
9247
9248   jresult = result;
9249   return jresult;
9250 }
9251
9252
9253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9254   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9255   uint16_t arg2 ;
9256
9257   arg1 = (Dali::Uint16Pair *)jarg1;
9258   arg2 = (uint16_t)jarg2;
9259   {
9260     try {
9261       (arg1)->SetY(arg2);
9262     } catch (std::out_of_range& e) {
9263       {
9264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9265       };
9266     } catch (std::exception& e) {
9267       {
9268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9269       };
9270     } catch (Dali::DaliException e) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9273       };
9274     } catch (...) {
9275       {
9276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9277       };
9278     }
9279   }
9280
9281 }
9282
9283
9284 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9285   unsigned short jresult ;
9286   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9287   uint16_t result;
9288
9289   arg1 = (Dali::Uint16Pair *)jarg1;
9290   {
9291     try {
9292       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9293     } catch (std::out_of_range& e) {
9294       {
9295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9296       };
9297     } catch (std::exception& e) {
9298       {
9299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9300       };
9301     } catch (Dali::DaliException e) {
9302       {
9303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9304       };
9305     } catch (...) {
9306       {
9307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9308       };
9309     }
9310   }
9311
9312   jresult = result;
9313   return jresult;
9314 }
9315
9316
9317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9318   void * jresult ;
9319   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9320   Dali::Uint16Pair *arg2 = 0 ;
9321   Dali::Uint16Pair *result = 0 ;
9322
9323   arg1 = (Dali::Uint16Pair *)jarg1;
9324   arg2 = (Dali::Uint16Pair *)jarg2;
9325   if (!arg2) {
9326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9327     return 0;
9328   }
9329   {
9330     try {
9331       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9332     } catch (std::out_of_range& e) {
9333       {
9334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9335       };
9336     } catch (std::exception& e) {
9337       {
9338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9339       };
9340     } catch (Dali::DaliException e) {
9341       {
9342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9343       };
9344     } catch (...) {
9345       {
9346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9347       };
9348     }
9349   }
9350
9351   jresult = (void *)result;
9352   return jresult;
9353 }
9354
9355
9356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9357   unsigned int jresult ;
9358   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9359   Dali::Uint16Pair *arg2 = 0 ;
9360   bool result;
9361
9362   arg1 = (Dali::Uint16Pair *)jarg1;
9363   arg2 = (Dali::Uint16Pair *)jarg2;
9364   if (!arg2) {
9365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9366     return 0;
9367   }
9368   {
9369     try {
9370       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9371     } catch (std::out_of_range& e) {
9372       {
9373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9374       };
9375     } catch (std::exception& e) {
9376       {
9377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9378       };
9379     } catch (Dali::DaliException e) {
9380       {
9381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9382       };
9383     } catch (...) {
9384       {
9385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9386       };
9387     }
9388   }
9389
9390   jresult = result;
9391   return jresult;
9392 }
9393
9394
9395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9396   unsigned int jresult ;
9397   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9398   Dali::Uint16Pair *arg2 = 0 ;
9399   bool result;
9400
9401   arg1 = (Dali::Uint16Pair *)jarg1;
9402   arg2 = (Dali::Uint16Pair *)jarg2;
9403   if (!arg2) {
9404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9405     return 0;
9406   }
9407   {
9408     try {
9409       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (Dali::DaliException e) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9421       };
9422     } catch (...) {
9423       {
9424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9425       };
9426     }
9427   }
9428
9429   jresult = result;
9430   return jresult;
9431 }
9432
9433
9434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9435   unsigned int jresult ;
9436   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9437   Dali::Uint16Pair *arg2 = 0 ;
9438   bool result;
9439
9440   arg1 = (Dali::Uint16Pair *)jarg1;
9441   arg2 = (Dali::Uint16Pair *)jarg2;
9442   if (!arg2) {
9443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9444     return 0;
9445   }
9446   {
9447     try {
9448       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9449     } catch (std::out_of_range& e) {
9450       {
9451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9452       };
9453     } catch (std::exception& e) {
9454       {
9455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9456       };
9457     } catch (Dali::DaliException e) {
9458       {
9459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9460       };
9461     } catch (...) {
9462       {
9463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9464       };
9465     }
9466   }
9467
9468   jresult = result;
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9474   unsigned int jresult ;
9475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9476   Dali::Uint16Pair *arg2 = 0 ;
9477   bool result;
9478
9479   arg1 = (Dali::Uint16Pair *)jarg1;
9480   arg2 = (Dali::Uint16Pair *)jarg2;
9481   if (!arg2) {
9482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9483     return 0;
9484   }
9485   {
9486     try {
9487       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9488     } catch (std::out_of_range& e) {
9489       {
9490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9491       };
9492     } catch (std::exception& e) {
9493       {
9494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9495       };
9496     } catch (Dali::DaliException e) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9499       };
9500     } catch (...) {
9501       {
9502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9503       };
9504     }
9505   }
9506
9507   jresult = result;
9508   return jresult;
9509 }
9510
9511
9512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9513   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9514
9515   arg1 = (Dali::Uint16Pair *)jarg1;
9516   {
9517     try {
9518       delete arg1;
9519     } catch (std::out_of_range& e) {
9520       {
9521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9522       };
9523     } catch (std::exception& e) {
9524       {
9525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9526       };
9527     } catch (Dali::DaliException e) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9530       };
9531     } catch (...) {
9532       {
9533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9534       };
9535     }
9536   }
9537
9538 }
9539
9540
9541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9542   void * jresult ;
9543   Dali::Degree *result = 0 ;
9544
9545   {
9546     try {
9547       result = (Dali::Degree *)new Dali::Degree();
9548     } catch (std::out_of_range& e) {
9549       {
9550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9551       };
9552     } catch (std::exception& e) {
9553       {
9554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9555       };
9556     } catch (Dali::DaliException e) {
9557       {
9558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9559       };
9560     } catch (...) {
9561       {
9562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9563       };
9564     }
9565   }
9566
9567   jresult = (void *)result;
9568   return jresult;
9569 }
9570
9571
9572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9573   void * jresult ;
9574   float arg1 ;
9575   Dali::Degree *result = 0 ;
9576
9577   arg1 = (float)jarg1;
9578   {
9579     try {
9580       result = (Dali::Degree *)new Dali::Degree(arg1);
9581     } catch (std::out_of_range& e) {
9582       {
9583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9584       };
9585     } catch (std::exception& e) {
9586       {
9587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9588       };
9589     } catch (Dali::DaliException e) {
9590       {
9591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9592       };
9593     } catch (...) {
9594       {
9595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9596       };
9597     }
9598   }
9599
9600   jresult = (void *)result;
9601   return jresult;
9602 }
9603
9604
9605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9606   void * jresult ;
9607   Dali::Radian arg1 ;
9608   Dali::Radian *argp1 ;
9609   Dali::Degree *result = 0 ;
9610
9611   argp1 = (Dali::Radian *)jarg1;
9612   if (!argp1) {
9613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9614     return 0;
9615   }
9616   arg1 = *argp1;
9617   {
9618     try {
9619       result = (Dali::Degree *)new Dali::Degree(arg1);
9620     } catch (std::out_of_range& e) {
9621       {
9622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (std::exception& e) {
9625       {
9626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (Dali::DaliException e) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9631       };
9632     } catch (...) {
9633       {
9634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9635       };
9636     }
9637   }
9638
9639   jresult = (void *)result;
9640   return jresult;
9641 }
9642
9643
9644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9645   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9646   float arg2 ;
9647
9648   arg1 = (Dali::Degree *)jarg1;
9649   arg2 = (float)jarg2;
9650   if (arg1) (arg1)->degree = arg2;
9651 }
9652
9653
9654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9655   float jresult ;
9656   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9657   float result;
9658
9659   arg1 = (Dali::Degree *)jarg1;
9660   result = (float) ((arg1)->degree);
9661   jresult = result;
9662   return jresult;
9663 }
9664
9665
9666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9667   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9668
9669   arg1 = (Dali::Degree *)jarg1;
9670   {
9671     try {
9672       delete arg1;
9673     } catch (std::out_of_range& e) {
9674       {
9675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9676       };
9677     } catch (std::exception& e) {
9678       {
9679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9680       };
9681     } catch (Dali::DaliException e) {
9682       {
9683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9684       };
9685     } catch (...) {
9686       {
9687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9688       };
9689     }
9690   }
9691
9692 }
9693
9694
9695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9696   void * jresult ;
9697   Dali::Radian *result = 0 ;
9698
9699   result = (Dali::Radian *)&Dali::ANGLE_360;
9700   jresult = (void *)result;
9701   return jresult;
9702 }
9703
9704
9705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9706   void * jresult ;
9707   Dali::Radian *result = 0 ;
9708
9709   result = (Dali::Radian *)&Dali::ANGLE_315;
9710   jresult = (void *)result;
9711   return jresult;
9712 }
9713
9714
9715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9716   void * jresult ;
9717   Dali::Radian *result = 0 ;
9718
9719   result = (Dali::Radian *)&Dali::ANGLE_270;
9720   jresult = (void *)result;
9721   return jresult;
9722 }
9723
9724
9725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9726   void * jresult ;
9727   Dali::Radian *result = 0 ;
9728
9729   result = (Dali::Radian *)&Dali::ANGLE_225;
9730   jresult = (void *)result;
9731   return jresult;
9732 }
9733
9734
9735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9736   void * jresult ;
9737   Dali::Radian *result = 0 ;
9738
9739   result = (Dali::Radian *)&Dali::ANGLE_180;
9740   jresult = (void *)result;
9741   return jresult;
9742 }
9743
9744
9745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9746   void * jresult ;
9747   Dali::Radian *result = 0 ;
9748
9749   result = (Dali::Radian *)&Dali::ANGLE_135;
9750   jresult = (void *)result;
9751   return jresult;
9752 }
9753
9754
9755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9756   void * jresult ;
9757   Dali::Radian *result = 0 ;
9758
9759   result = (Dali::Radian *)&Dali::ANGLE_120;
9760   jresult = (void *)result;
9761   return jresult;
9762 }
9763
9764
9765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9766   void * jresult ;
9767   Dali::Radian *result = 0 ;
9768
9769   result = (Dali::Radian *)&Dali::ANGLE_90;
9770   jresult = (void *)result;
9771   return jresult;
9772 }
9773
9774
9775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9776   void * jresult ;
9777   Dali::Radian *result = 0 ;
9778
9779   result = (Dali::Radian *)&Dali::ANGLE_60;
9780   jresult = (void *)result;
9781   return jresult;
9782 }
9783
9784
9785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9786   void * jresult ;
9787   Dali::Radian *result = 0 ;
9788
9789   result = (Dali::Radian *)&Dali::ANGLE_45;
9790   jresult = (void *)result;
9791   return jresult;
9792 }
9793
9794
9795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9796   void * jresult ;
9797   Dali::Radian *result = 0 ;
9798
9799   result = (Dali::Radian *)&Dali::ANGLE_30;
9800   jresult = (void *)result;
9801   return jresult;
9802 }
9803
9804
9805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9806   void * jresult ;
9807   Dali::Radian *result = 0 ;
9808
9809   result = (Dali::Radian *)&Dali::ANGLE_0;
9810   jresult = (void *)result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9816   unsigned int jresult ;
9817   Dali::Degree *arg1 = 0 ;
9818   Dali::Degree *arg2 = 0 ;
9819   bool result;
9820
9821   arg1 = (Dali::Degree *)jarg1;
9822   if (!arg1) {
9823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9824     return 0;
9825   }
9826   arg2 = (Dali::Degree *)jarg2;
9827   if (!arg2) {
9828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9829     return 0;
9830   }
9831   {
9832     try {
9833       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9834     } catch (std::out_of_range& e) {
9835       {
9836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (std::exception& e) {
9839       {
9840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9841       };
9842     } catch (Dali::DaliException e) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9845       };
9846     } catch (...) {
9847       {
9848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9849       };
9850     }
9851   }
9852
9853   jresult = result;
9854   return jresult;
9855 }
9856
9857
9858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9859   unsigned int jresult ;
9860   Dali::Degree *arg1 = 0 ;
9861   Dali::Degree *arg2 = 0 ;
9862   bool result;
9863
9864   arg1 = (Dali::Degree *)jarg1;
9865   if (!arg1) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9867     return 0;
9868   }
9869   arg2 = (Dali::Degree *)jarg2;
9870   if (!arg2) {
9871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9872     return 0;
9873   }
9874   {
9875     try {
9876       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9877     } catch (std::out_of_range& e) {
9878       {
9879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (std::exception& e) {
9882       {
9883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9884       };
9885     } catch (Dali::DaliException e) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9888       };
9889     } catch (...) {
9890       {
9891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9892       };
9893     }
9894   }
9895
9896   jresult = result;
9897   return jresult;
9898 }
9899
9900
9901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9902   void * jresult ;
9903   Dali::Degree arg1 ;
9904   float arg2 ;
9905   float arg3 ;
9906   Dali::Degree *argp1 ;
9907   Dali::Degree result;
9908
9909   argp1 = (Dali::Degree *)jarg1;
9910   if (!argp1) {
9911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9912     return 0;
9913   }
9914   arg1 = *argp1;
9915   arg2 = (float)jarg2;
9916   arg3 = (float)jarg3;
9917   {
9918     try {
9919       result = Dali::Clamp(arg1,arg2,arg3);
9920     } catch (std::out_of_range& e) {
9921       {
9922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (std::exception& e) {
9925       {
9926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (Dali::DaliException e) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938
9939   jresult = new Dali::Degree((const Dali::Degree &)result);
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9945   void * jresult ;
9946   Dali::Radian *result = 0 ;
9947
9948   {
9949     try {
9950       result = (Dali::Radian *)new Dali::Radian();
9951     } catch (std::out_of_range& e) {
9952       {
9953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (std::exception& e) {
9956       {
9957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9958       };
9959     } catch (Dali::DaliException e) {
9960       {
9961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9962       };
9963     } catch (...) {
9964       {
9965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9966       };
9967     }
9968   }
9969
9970   jresult = (void *)result;
9971   return jresult;
9972 }
9973
9974
9975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9976   void * jresult ;
9977   float arg1 ;
9978   Dali::Radian *result = 0 ;
9979
9980   arg1 = (float)jarg1;
9981   {
9982     try {
9983       result = (Dali::Radian *)new Dali::Radian(arg1);
9984     } catch (std::out_of_range& e) {
9985       {
9986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9987       };
9988     } catch (std::exception& e) {
9989       {
9990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9991       };
9992     } catch (Dali::DaliException e) {
9993       {
9994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9995       };
9996     } catch (...) {
9997       {
9998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9999       };
10000     }
10001   }
10002
10003   jresult = (void *)result;
10004   return jresult;
10005 }
10006
10007
10008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10009   void * jresult ;
10010   Dali::Degree arg1 ;
10011   Dali::Degree *argp1 ;
10012   Dali::Radian *result = 0 ;
10013
10014   argp1 = (Dali::Degree *)jarg1;
10015   if (!argp1) {
10016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10017     return 0;
10018   }
10019   arg1 = *argp1;
10020   {
10021     try {
10022       result = (Dali::Radian *)new Dali::Radian(arg1);
10023     } catch (std::out_of_range& e) {
10024       {
10025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10026       };
10027     } catch (std::exception& e) {
10028       {
10029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10030       };
10031     } catch (Dali::DaliException e) {
10032       {
10033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10034       };
10035     } catch (...) {
10036       {
10037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10038       };
10039     }
10040   }
10041
10042   jresult = (void *)result;
10043   return jresult;
10044 }
10045
10046
10047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10048   void * jresult ;
10049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10050   float arg2 ;
10051   Dali::Radian *result = 0 ;
10052
10053   arg1 = (Dali::Radian *)jarg1;
10054   arg2 = (float)jarg2;
10055   {
10056     try {
10057       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10058     } catch (std::out_of_range& e) {
10059       {
10060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (std::exception& e) {
10063       {
10064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10065       };
10066     } catch (Dali::DaliException e) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10069       };
10070     } catch (...) {
10071       {
10072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10073       };
10074     }
10075   }
10076
10077   jresult = (void *)result;
10078   return jresult;
10079 }
10080
10081
10082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10083   void * jresult ;
10084   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10085   Dali::Degree arg2 ;
10086   Dali::Degree *argp2 ;
10087   Dali::Radian *result = 0 ;
10088
10089   arg1 = (Dali::Radian *)jarg1;
10090   argp2 = (Dali::Degree *)jarg2;
10091   if (!argp2) {
10092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10093     return 0;
10094   }
10095   arg2 = *argp2;
10096   {
10097     try {
10098       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10099     } catch (std::out_of_range& e) {
10100       {
10101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (std::exception& e) {
10104       {
10105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10106       };
10107     } catch (Dali::DaliException e) {
10108       {
10109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10110       };
10111     } catch (...) {
10112       {
10113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10114       };
10115     }
10116   }
10117
10118   jresult = (void *)result;
10119   return jresult;
10120 }
10121
10122
10123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10124   float jresult ;
10125   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10126   float result;
10127
10128   arg1 = (Dali::Radian *)jarg1;
10129   {
10130     try {
10131       result = (float)((Dali::Radian const *)arg1)->operator float();
10132     } catch (std::out_of_range& e) {
10133       {
10134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10135       };
10136     } catch (std::exception& e) {
10137       {
10138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10139       };
10140     } catch (Dali::DaliException e) {
10141       {
10142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10143       };
10144     } catch (...) {
10145       {
10146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10147       };
10148     }
10149   }
10150
10151   jresult = result;
10152   return jresult;
10153 }
10154
10155
10156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10157   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10158   float arg2 ;
10159
10160   arg1 = (Dali::Radian *)jarg1;
10161   arg2 = (float)jarg2;
10162   if (arg1) (arg1)->radian = arg2;
10163 }
10164
10165
10166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10167   float jresult ;
10168   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10169   float result;
10170
10171   arg1 = (Dali::Radian *)jarg1;
10172   result = (float) ((arg1)->radian);
10173   jresult = result;
10174   return jresult;
10175 }
10176
10177
10178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10179   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10180
10181   arg1 = (Dali::Radian *)jarg1;
10182   {
10183     try {
10184       delete arg1;
10185     } catch (std::out_of_range& e) {
10186       {
10187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10188       };
10189     } catch (std::exception& e) {
10190       {
10191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10192       };
10193     } catch (Dali::DaliException e) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10196       };
10197     } catch (...) {
10198       {
10199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10200       };
10201     }
10202   }
10203
10204 }
10205
10206
10207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10208   unsigned int jresult ;
10209   Dali::Radian arg1 ;
10210   Dali::Radian arg2 ;
10211   Dali::Radian *argp1 ;
10212   Dali::Radian *argp2 ;
10213   bool result;
10214
10215   argp1 = (Dali::Radian *)jarg1;
10216   if (!argp1) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg1 = *argp1;
10221   argp2 = (Dali::Radian *)jarg2;
10222   if (!argp2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10224     return 0;
10225   }
10226   arg2 = *argp2;
10227   {
10228     try {
10229       result = (bool)Dali::operator ==(arg1,arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (Dali::DaliException e) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10241       };
10242     } catch (...) {
10243       {
10244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10245       };
10246     }
10247   }
10248
10249   jresult = result;
10250   return jresult;
10251 }
10252
10253
10254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10255   unsigned int jresult ;
10256   Dali::Radian arg1 ;
10257   Dali::Radian arg2 ;
10258   Dali::Radian *argp1 ;
10259   Dali::Radian *argp2 ;
10260   bool result;
10261
10262   argp1 = (Dali::Radian *)jarg1;
10263   if (!argp1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg1 = *argp1;
10268   argp2 = (Dali::Radian *)jarg2;
10269   if (!argp2) {
10270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10271     return 0;
10272   }
10273   arg2 = *argp2;
10274   {
10275     try {
10276       result = (bool)Dali::operator !=(arg1,arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (Dali::DaliException e) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10288       };
10289     } catch (...) {
10290       {
10291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10292       };
10293     }
10294   }
10295
10296   jresult = result;
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10302   unsigned int jresult ;
10303   Dali::Radian arg1 ;
10304   Dali::Degree arg2 ;
10305   Dali::Radian *argp1 ;
10306   Dali::Degree *argp2 ;
10307   bool result;
10308
10309   argp1 = (Dali::Radian *)jarg1;
10310   if (!argp1) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10312     return 0;
10313   }
10314   arg1 = *argp1;
10315   argp2 = (Dali::Degree *)jarg2;
10316   if (!argp2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10318     return 0;
10319   }
10320   arg2 = *argp2;
10321   {
10322     try {
10323       result = (bool)Dali::operator ==(arg1,arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (Dali::DaliException e) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342
10343   jresult = result;
10344   return jresult;
10345 }
10346
10347
10348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10349   unsigned int jresult ;
10350   Dali::Radian arg1 ;
10351   Dali::Degree arg2 ;
10352   Dali::Radian *argp1 ;
10353   Dali::Degree *argp2 ;
10354   bool result;
10355
10356   argp1 = (Dali::Radian *)jarg1;
10357   if (!argp1) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10359     return 0;
10360   }
10361   arg1 = *argp1;
10362   argp2 = (Dali::Degree *)jarg2;
10363   if (!argp2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10365     return 0;
10366   }
10367   arg2 = *argp2;
10368   {
10369     try {
10370       result = (bool)Dali::operator !=(arg1,arg2);
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (Dali::DaliException e) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10382       };
10383     } catch (...) {
10384       {
10385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10386       };
10387     }
10388   }
10389
10390   jresult = result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10396   unsigned int jresult ;
10397   Dali::Degree arg1 ;
10398   Dali::Radian arg2 ;
10399   Dali::Degree *argp1 ;
10400   Dali::Radian *argp2 ;
10401   bool result;
10402
10403   argp1 = (Dali::Degree *)jarg1;
10404   if (!argp1) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10406     return 0;
10407   }
10408   arg1 = *argp1;
10409   argp2 = (Dali::Radian *)jarg2;
10410   if (!argp2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10412     return 0;
10413   }
10414   arg2 = *argp2;
10415   {
10416     try {
10417       result = (bool)Dali::operator ==(arg1,arg2);
10418     } catch (std::out_of_range& e) {
10419       {
10420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (std::exception& e) {
10423       {
10424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10425       };
10426     } catch (Dali::DaliException e) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10429       };
10430     } catch (...) {
10431       {
10432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10433       };
10434     }
10435   }
10436
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10443   unsigned int jresult ;
10444   Dali::Degree arg1 ;
10445   Dali::Radian arg2 ;
10446   Dali::Degree *argp1 ;
10447   Dali::Radian *argp2 ;
10448   bool result;
10449
10450   argp1 = (Dali::Degree *)jarg1;
10451   if (!argp1) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10453     return 0;
10454   }
10455   arg1 = *argp1;
10456   argp2 = (Dali::Radian *)jarg2;
10457   if (!argp2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10459     return 0;
10460   }
10461   arg2 = *argp2;
10462   {
10463     try {
10464       result = (bool)Dali::operator !=(arg1,arg2);
10465     } catch (std::out_of_range& e) {
10466       {
10467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (std::exception& e) {
10470       {
10471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10472       };
10473     } catch (Dali::DaliException e) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10480       };
10481     }
10482   }
10483
10484   jresult = result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10490   unsigned int jresult ;
10491   Dali::Radian arg1 ;
10492   Dali::Radian arg2 ;
10493   Dali::Radian *argp1 ;
10494   Dali::Radian *argp2 ;
10495   bool result;
10496
10497   argp1 = (Dali::Radian *)jarg1;
10498   if (!argp1) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg1 = *argp1;
10503   argp2 = (Dali::Radian *)jarg2;
10504   if (!argp2) {
10505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10506     return 0;
10507   }
10508   arg2 = *argp2;
10509   {
10510     try {
10511       result = (bool)Dali::operator >(arg1,arg2);
10512     } catch (std::out_of_range& e) {
10513       {
10514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (std::exception& e) {
10517       {
10518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10519       };
10520     } catch (Dali::DaliException e) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10523       };
10524     } catch (...) {
10525       {
10526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10527       };
10528     }
10529   }
10530
10531   jresult = result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10537   unsigned int jresult ;
10538   Dali::Radian arg1 ;
10539   Dali::Degree arg2 ;
10540   Dali::Radian *argp1 ;
10541   Dali::Degree *argp2 ;
10542   bool result;
10543
10544   argp1 = (Dali::Radian *)jarg1;
10545   if (!argp1) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10547     return 0;
10548   }
10549   arg1 = *argp1;
10550   argp2 = (Dali::Degree *)jarg2;
10551   if (!argp2) {
10552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10553     return 0;
10554   }
10555   arg2 = *argp2;
10556   {
10557     try {
10558       result = (bool)Dali::operator >(arg1,arg2);
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10566       };
10567     } catch (Dali::DaliException e) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10570       };
10571     } catch (...) {
10572       {
10573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10574       };
10575     }
10576   }
10577
10578   jresult = result;
10579   return jresult;
10580 }
10581
10582
10583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10584   unsigned int jresult ;
10585   Dali::Degree arg1 ;
10586   Dali::Radian arg2 ;
10587   Dali::Degree *argp1 ;
10588   Dali::Radian *argp2 ;
10589   bool result;
10590
10591   argp1 = (Dali::Degree *)jarg1;
10592   if (!argp1) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10594     return 0;
10595   }
10596   arg1 = *argp1;
10597   argp2 = (Dali::Radian *)jarg2;
10598   if (!argp2) {
10599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10600     return 0;
10601   }
10602   arg2 = *argp2;
10603   {
10604     try {
10605       result = (bool)Dali::operator >(arg1,arg2);
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (Dali::DaliException e) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10631   unsigned int jresult ;
10632   Dali::Radian arg1 ;
10633   Dali::Radian arg2 ;
10634   Dali::Radian *argp1 ;
10635   Dali::Radian *argp2 ;
10636   bool result;
10637
10638   argp1 = (Dali::Radian *)jarg1;
10639   if (!argp1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg1 = *argp1;
10644   argp2 = (Dali::Radian *)jarg2;
10645   if (!argp2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10647     return 0;
10648   }
10649   arg2 = *argp2;
10650   {
10651     try {
10652       result = (bool)Dali::operator <(arg1,arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (Dali::DaliException e) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10664       };
10665     } catch (...) {
10666       {
10667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10668       };
10669     }
10670   }
10671
10672   jresult = result;
10673   return jresult;
10674 }
10675
10676
10677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10678   unsigned int jresult ;
10679   Dali::Radian arg1 ;
10680   Dali::Degree arg2 ;
10681   Dali::Radian *argp1 ;
10682   Dali::Degree *argp2 ;
10683   bool result;
10684
10685   argp1 = (Dali::Radian *)jarg1;
10686   if (!argp1) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10688     return 0;
10689   }
10690   arg1 = *argp1;
10691   argp2 = (Dali::Degree *)jarg2;
10692   if (!argp2) {
10693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10694     return 0;
10695   }
10696   arg2 = *argp2;
10697   {
10698     try {
10699       result = (bool)Dali::operator <(arg1,arg2);
10700     } catch (std::out_of_range& e) {
10701       {
10702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (std::exception& e) {
10705       {
10706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10707       };
10708     } catch (Dali::DaliException e) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10711       };
10712     } catch (...) {
10713       {
10714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10715       };
10716     }
10717   }
10718
10719   jresult = result;
10720   return jresult;
10721 }
10722
10723
10724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10725   unsigned int jresult ;
10726   Dali::Degree arg1 ;
10727   Dali::Radian arg2 ;
10728   Dali::Degree *argp1 ;
10729   Dali::Radian *argp2 ;
10730   bool result;
10731
10732   argp1 = (Dali::Degree *)jarg1;
10733   if (!argp1) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10735     return 0;
10736   }
10737   arg1 = *argp1;
10738   argp2 = (Dali::Radian *)jarg2;
10739   if (!argp2) {
10740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10741     return 0;
10742   }
10743   arg2 = *argp2;
10744   {
10745     try {
10746       result = (bool)Dali::operator <(arg1,arg2);
10747     } catch (std::out_of_range& e) {
10748       {
10749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (std::exception& e) {
10752       {
10753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10754       };
10755     } catch (Dali::DaliException e) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10758       };
10759     } catch (...) {
10760       {
10761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10762       };
10763     }
10764   }
10765
10766   jresult = result;
10767   return jresult;
10768 }
10769
10770
10771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10772   void * jresult ;
10773   Dali::Radian arg1 ;
10774   float arg2 ;
10775   Dali::Radian *argp1 ;
10776   Dali::Radian result;
10777
10778   argp1 = (Dali::Radian *)jarg1;
10779   if (!argp1) {
10780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10781     return 0;
10782   }
10783   arg1 = *argp1;
10784   arg2 = (float)jarg2;
10785   {
10786     try {
10787       result = Dali::operator *(arg1,arg2);
10788     } catch (std::out_of_range& e) {
10789       {
10790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10791       };
10792     } catch (std::exception& e) {
10793       {
10794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10795       };
10796     } catch (Dali::DaliException e) {
10797       {
10798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10799       };
10800     } catch (...) {
10801       {
10802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10803       };
10804     }
10805   }
10806
10807   jresult = new Dali::Radian((const Dali::Radian &)result);
10808   return jresult;
10809 }
10810
10811
10812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10813   void * jresult ;
10814   Dali::Radian arg1 ;
10815   Dali::Radian *argp1 ;
10816   Dali::Radian result;
10817
10818   argp1 = (Dali::Radian *)jarg1;
10819   if (!argp1) {
10820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10821     return 0;
10822   }
10823   arg1 = *argp1;
10824   {
10825     try {
10826       result = Dali::operator -(arg1);
10827     } catch (std::out_of_range& e) {
10828       {
10829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (std::exception& e) {
10832       {
10833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10834       };
10835     } catch (Dali::DaliException e) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10838       };
10839     } catch (...) {
10840       {
10841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10842       };
10843     }
10844   }
10845
10846   jresult = new Dali::Radian((const Dali::Radian &)result);
10847   return jresult;
10848 }
10849
10850
10851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10852   void * jresult ;
10853   Dali::Radian arg1 ;
10854   float arg2 ;
10855   float arg3 ;
10856   Dali::Radian *argp1 ;
10857   Dali::Radian result;
10858
10859   argp1 = (Dali::Radian *)jarg1;
10860   if (!argp1) {
10861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10862     return 0;
10863   }
10864   arg1 = *argp1;
10865   arg2 = (float)jarg2;
10866   arg3 = (float)jarg3;
10867   {
10868     try {
10869       result = Dali::Clamp(arg1,arg2,arg3);
10870     } catch (std::out_of_range& e) {
10871       {
10872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (std::exception& e) {
10875       {
10876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10877       };
10878     } catch (Dali::DaliException e) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10881       };
10882     } catch (...) {
10883       {
10884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10885       };
10886     }
10887   }
10888
10889   jresult = new Dali::Radian((const Dali::Radian &)result);
10890   return jresult;
10891 }
10892
10893
10894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10895   void * jresult ;
10896   Dali::Quaternion *result = 0 ;
10897
10898   {
10899     try {
10900       result = (Dali::Quaternion *)new Dali::Quaternion();
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (Dali::DaliException e) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10912       };
10913     } catch (...) {
10914       {
10915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10916       };
10917     }
10918   }
10919
10920   jresult = (void *)result;
10921   return jresult;
10922 }
10923
10924
10925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10926   void * jresult ;
10927   Dali::Radian arg1 ;
10928   Dali::Vector3 *arg2 = 0 ;
10929   Dali::Radian *argp1 ;
10930   Dali::Quaternion *result = 0 ;
10931
10932   argp1 = (Dali::Radian *)jarg1;
10933   if (!argp1) {
10934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10935     return 0;
10936   }
10937   arg1 = *argp1;
10938   arg2 = (Dali::Vector3 *)jarg2;
10939   if (!arg2) {
10940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10941     return 0;
10942   }
10943   {
10944     try {
10945       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10946     } catch (std::out_of_range& e) {
10947       {
10948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10949       };
10950     } catch (std::exception& e) {
10951       {
10952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10953       };
10954     } catch (Dali::DaliException e) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10957       };
10958     } catch (...) {
10959       {
10960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10961       };
10962     }
10963   }
10964
10965   jresult = (void *)result;
10966   return jresult;
10967 }
10968
10969
10970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10971   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10972
10973   arg1 = (Dali::Quaternion *)jarg1;
10974   {
10975     try {
10976       delete arg1;
10977     } catch (std::out_of_range& e) {
10978       {
10979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10980       };
10981     } catch (std::exception& e) {
10982       {
10983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10984       };
10985     } catch (Dali::DaliException e) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10988       };
10989     } catch (...) {
10990       {
10991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10992       };
10993     }
10994   }
10995
10996 }
10997
10998
10999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11000   void * jresult ;
11001   Dali::Quaternion *result = 0 ;
11002
11003   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11004   jresult = (void *)result;
11005   return jresult;
11006 }
11007
11008
11009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11010   unsigned int jresult ;
11011   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11012   bool result;
11013
11014   arg1 = (Dali::Quaternion *)jarg1;
11015   {
11016     try {
11017       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11018     } catch (std::out_of_range& e) {
11019       {
11020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (std::exception& e) {
11023       {
11024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11025       };
11026     } catch (Dali::DaliException e) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11029       };
11030     } catch (...) {
11031       {
11032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11033       };
11034     }
11035   }
11036
11037   jresult = result;
11038   return jresult;
11039 }
11040
11041
11042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11043   unsigned int jresult ;
11044   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11045   Dali::Vector3 *arg2 = 0 ;
11046   Dali::Radian *arg3 = 0 ;
11047   bool result;
11048
11049   arg1 = (Dali::Quaternion *)jarg1;
11050   arg2 = (Dali::Vector3 *)jarg2;
11051   if (!arg2) {
11052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11053     return 0;
11054   }
11055   arg3 = (Dali::Radian *)jarg3;
11056   if (!arg3) {
11057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11058     return 0;
11059   }
11060   {
11061     try {
11062       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11063     } catch (std::out_of_range& e) {
11064       {
11065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11066       };
11067     } catch (std::exception& e) {
11068       {
11069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11070       };
11071     } catch (Dali::DaliException e) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11074       };
11075     } catch (...) {
11076       {
11077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11078       };
11079     }
11080   }
11081
11082   jresult = result;
11083   return jresult;
11084 }
11085
11086
11087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11088   void * jresult ;
11089   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11090   Dali::Quaternion *arg2 = 0 ;
11091   Dali::Quaternion result;
11092
11093   arg1 = (Dali::Quaternion *)jarg1;
11094   arg2 = (Dali::Quaternion *)jarg2;
11095   if (!arg2) {
11096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11097     return 0;
11098   }
11099   {
11100     try {
11101       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11102     } catch (std::out_of_range& e) {
11103       {
11104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11105       };
11106     } catch (std::exception& e) {
11107       {
11108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11109       };
11110     } catch (Dali::DaliException e) {
11111       {
11112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11113       };
11114     } catch (...) {
11115       {
11116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11117       };
11118     }
11119   }
11120
11121   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11127   void * jresult ;
11128   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11129   Dali::Quaternion *arg2 = 0 ;
11130   Dali::Quaternion result;
11131
11132   arg1 = (Dali::Quaternion *)jarg1;
11133   arg2 = (Dali::Quaternion *)jarg2;
11134   if (!arg2) {
11135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11136     return 0;
11137   }
11138   {
11139     try {
11140       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11148       };
11149     } catch (Dali::DaliException e) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11152       };
11153     } catch (...) {
11154       {
11155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11156       };
11157     }
11158   }
11159
11160   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11161   return jresult;
11162 }
11163
11164
11165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11166   void * jresult ;
11167   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11168   Dali::Quaternion *arg2 = 0 ;
11169   Dali::Quaternion result;
11170
11171   arg1 = (Dali::Quaternion *)jarg1;
11172   arg2 = (Dali::Quaternion *)jarg2;
11173   if (!arg2) {
11174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11175     return 0;
11176   }
11177   {
11178     try {
11179       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11180     } catch (std::out_of_range& e) {
11181       {
11182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11183       };
11184     } catch (std::exception& e) {
11185       {
11186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11187       };
11188     } catch (Dali::DaliException e) {
11189       {
11190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11191       };
11192     } catch (...) {
11193       {
11194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11195       };
11196     }
11197   }
11198
11199   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11200   return jresult;
11201 }
11202
11203
11204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11205   void * jresult ;
11206   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11207   Dali::Vector3 *arg2 = 0 ;
11208   Dali::Vector3 result;
11209
11210   arg1 = (Dali::Quaternion *)jarg1;
11211   arg2 = (Dali::Vector3 *)jarg2;
11212   if (!arg2) {
11213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11214     return 0;
11215   }
11216   {
11217     try {
11218       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11219     } catch (std::out_of_range& e) {
11220       {
11221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (std::exception& e) {
11224       {
11225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11226       };
11227     } catch (Dali::DaliException e) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11230       };
11231     } catch (...) {
11232       {
11233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11234       };
11235     }
11236   }
11237
11238   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11239   return jresult;
11240 }
11241
11242
11243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11244   void * jresult ;
11245   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11246   Dali::Quaternion *arg2 = 0 ;
11247   Dali::Quaternion result;
11248
11249   arg1 = (Dali::Quaternion *)jarg1;
11250   arg2 = (Dali::Quaternion *)jarg2;
11251   if (!arg2) {
11252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11253     return 0;
11254   }
11255   {
11256     try {
11257       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11258     } catch (std::out_of_range& e) {
11259       {
11260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11261       };
11262     } catch (std::exception& e) {
11263       {
11264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11265       };
11266     } catch (Dali::DaliException e) {
11267       {
11268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11269       };
11270     } catch (...) {
11271       {
11272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11273       };
11274     }
11275   }
11276
11277   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11278   return jresult;
11279 }
11280
11281
11282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11283   void * jresult ;
11284   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11285   float arg2 ;
11286   Dali::Quaternion result;
11287
11288   arg1 = (Dali::Quaternion *)jarg1;
11289   arg2 = (float)jarg2;
11290   {
11291     try {
11292       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11293     } catch (std::out_of_range& e) {
11294       {
11295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11296       };
11297     } catch (std::exception& e) {
11298       {
11299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11300       };
11301     } catch (Dali::DaliException e) {
11302       {
11303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11304       };
11305     } catch (...) {
11306       {
11307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11308       };
11309     }
11310   }
11311
11312   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11313   return jresult;
11314 }
11315
11316
11317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11318   void * jresult ;
11319   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11320   float arg2 ;
11321   Dali::Quaternion result;
11322
11323   arg1 = (Dali::Quaternion *)jarg1;
11324   arg2 = (float)jarg2;
11325   {
11326     try {
11327       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11328     } catch (std::out_of_range& e) {
11329       {
11330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11331       };
11332     } catch (std::exception& e) {
11333       {
11334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11335       };
11336     } catch (Dali::DaliException e) {
11337       {
11338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11339       };
11340     } catch (...) {
11341       {
11342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11343       };
11344     }
11345   }
11346
11347   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11348   return jresult;
11349 }
11350
11351
11352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11353   void * jresult ;
11354   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11355   Dali::Quaternion result;
11356
11357   arg1 = (Dali::Quaternion *)jarg1;
11358   {
11359     try {
11360       result = ((Dali::Quaternion const *)arg1)->operator -();
11361     } catch (std::out_of_range& e) {
11362       {
11363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (std::exception& e) {
11366       {
11367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11368       };
11369     } catch (Dali::DaliException e) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11372       };
11373     } catch (...) {
11374       {
11375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11376       };
11377     }
11378   }
11379
11380   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11381   return jresult;
11382 }
11383
11384
11385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11386   void * jresult ;
11387   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11388   Dali::Quaternion *arg2 = 0 ;
11389   Dali::Quaternion *result = 0 ;
11390
11391   arg1 = (Dali::Quaternion *)jarg1;
11392   arg2 = (Dali::Quaternion *)jarg2;
11393   if (!arg2) {
11394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11395     return 0;
11396   }
11397   {
11398     try {
11399       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11400     } catch (std::out_of_range& e) {
11401       {
11402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (std::exception& e) {
11405       {
11406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11407       };
11408     } catch (Dali::DaliException e) {
11409       {
11410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11411       };
11412     } catch (...) {
11413       {
11414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11415       };
11416     }
11417   }
11418
11419   jresult = (void *)result;
11420   return jresult;
11421 }
11422
11423
11424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11425   void * jresult ;
11426   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11427   Dali::Quaternion *arg2 = 0 ;
11428   Dali::Quaternion *result = 0 ;
11429
11430   arg1 = (Dali::Quaternion *)jarg1;
11431   arg2 = (Dali::Quaternion *)jarg2;
11432   if (!arg2) {
11433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11434     return 0;
11435   }
11436   {
11437     try {
11438       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11439     } catch (std::out_of_range& e) {
11440       {
11441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11442       };
11443     } catch (std::exception& e) {
11444       {
11445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11446       };
11447     } catch (Dali::DaliException e) {
11448       {
11449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11450       };
11451     } catch (...) {
11452       {
11453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11454       };
11455     }
11456   }
11457
11458   jresult = (void *)result;
11459   return jresult;
11460 }
11461
11462
11463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11464   void * jresult ;
11465   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11466   Dali::Quaternion *arg2 = 0 ;
11467   Dali::Quaternion *result = 0 ;
11468
11469   arg1 = (Dali::Quaternion *)jarg1;
11470   arg2 = (Dali::Quaternion *)jarg2;
11471   if (!arg2) {
11472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11473     return 0;
11474   }
11475   {
11476     try {
11477       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11478     } catch (std::out_of_range& e) {
11479       {
11480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11481       };
11482     } catch (std::exception& e) {
11483       {
11484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11485       };
11486     } catch (Dali::DaliException e) {
11487       {
11488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11489       };
11490     } catch (...) {
11491       {
11492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11493       };
11494     }
11495   }
11496
11497   jresult = (void *)result;
11498   return jresult;
11499 }
11500
11501
11502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11503   void * jresult ;
11504   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11505   float arg2 ;
11506   Dali::Quaternion *result = 0 ;
11507
11508   arg1 = (Dali::Quaternion *)jarg1;
11509   arg2 = (float)jarg2;
11510   {
11511     try {
11512       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11513     } catch (std::out_of_range& e) {
11514       {
11515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11516       };
11517     } catch (std::exception& e) {
11518       {
11519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11520       };
11521     } catch (Dali::DaliException e) {
11522       {
11523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11524       };
11525     } catch (...) {
11526       {
11527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11528       };
11529     }
11530   }
11531
11532   jresult = (void *)result;
11533   return jresult;
11534 }
11535
11536
11537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11538   void * jresult ;
11539   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11540   float arg2 ;
11541   Dali::Quaternion *result = 0 ;
11542
11543   arg1 = (Dali::Quaternion *)jarg1;
11544   arg2 = (float)jarg2;
11545   {
11546     try {
11547       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11548     } catch (std::out_of_range& e) {
11549       {
11550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11551       };
11552     } catch (std::exception& e) {
11553       {
11554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11555       };
11556     } catch (Dali::DaliException e) {
11557       {
11558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11559       };
11560     } catch (...) {
11561       {
11562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11563       };
11564     }
11565   }
11566
11567   jresult = (void *)result;
11568   return jresult;
11569 }
11570
11571
11572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11573   unsigned int jresult ;
11574   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11575   Dali::Quaternion *arg2 = 0 ;
11576   bool result;
11577
11578   arg1 = (Dali::Quaternion *)jarg1;
11579   arg2 = (Dali::Quaternion *)jarg2;
11580   if (!arg2) {
11581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11582     return 0;
11583   }
11584   {
11585     try {
11586       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11587     } catch (std::out_of_range& e) {
11588       {
11589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (std::exception& e) {
11592       {
11593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11594       };
11595     } catch (Dali::DaliException e) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11598       };
11599     } catch (...) {
11600       {
11601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11602       };
11603     }
11604   }
11605
11606   jresult = result;
11607   return jresult;
11608 }
11609
11610
11611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11612   unsigned int jresult ;
11613   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11614   Dali::Quaternion *arg2 = 0 ;
11615   bool result;
11616
11617   arg1 = (Dali::Quaternion *)jarg1;
11618   arg2 = (Dali::Quaternion *)jarg2;
11619   if (!arg2) {
11620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11621     return 0;
11622   }
11623   {
11624     try {
11625       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11626     } catch (std::out_of_range& e) {
11627       {
11628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11629       };
11630     } catch (std::exception& e) {
11631       {
11632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11633       };
11634     } catch (Dali::DaliException e) {
11635       {
11636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11637       };
11638     } catch (...) {
11639       {
11640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11641       };
11642     }
11643   }
11644
11645   jresult = result;
11646   return jresult;
11647 }
11648
11649
11650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11651   float jresult ;
11652   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11653   float result;
11654
11655   arg1 = (Dali::Quaternion *)jarg1;
11656   {
11657     try {
11658       result = (float)((Dali::Quaternion const *)arg1)->Length();
11659     } catch (std::out_of_range& e) {
11660       {
11661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (std::exception& e) {
11664       {
11665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11666       };
11667     } catch (Dali::DaliException e) {
11668       {
11669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11670       };
11671     } catch (...) {
11672       {
11673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11674       };
11675     }
11676   }
11677
11678   jresult = result;
11679   return jresult;
11680 }
11681
11682
11683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11684   float jresult ;
11685   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11686   float result;
11687
11688   arg1 = (Dali::Quaternion *)jarg1;
11689   {
11690     try {
11691       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11692     } catch (std::out_of_range& e) {
11693       {
11694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11695       };
11696     } catch (std::exception& e) {
11697       {
11698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11699       };
11700     } catch (Dali::DaliException e) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11703       };
11704     } catch (...) {
11705       {
11706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11707       };
11708     }
11709   }
11710
11711   jresult = result;
11712   return jresult;
11713 }
11714
11715
11716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11717   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11718
11719   arg1 = (Dali::Quaternion *)jarg1;
11720   {
11721     try {
11722       (arg1)->Normalize();
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11730       };
11731     } catch (Dali::DaliException e) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11734       };
11735     } catch (...) {
11736       {
11737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11738       };
11739     }
11740   }
11741
11742 }
11743
11744
11745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11746   void * jresult ;
11747   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11748   Dali::Quaternion result;
11749
11750   arg1 = (Dali::Quaternion *)jarg1;
11751   {
11752     try {
11753       result = ((Dali::Quaternion const *)arg1)->Normalized();
11754     } catch (std::out_of_range& e) {
11755       {
11756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11757       };
11758     } catch (std::exception& e) {
11759       {
11760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11761       };
11762     } catch (Dali::DaliException e) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11765       };
11766     } catch (...) {
11767       {
11768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11769       };
11770     }
11771   }
11772
11773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11774   return jresult;
11775 }
11776
11777
11778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11779   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11780
11781   arg1 = (Dali::Quaternion *)jarg1;
11782   {
11783     try {
11784       (arg1)->Conjugate();
11785     } catch (std::out_of_range& e) {
11786       {
11787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (std::exception& e) {
11790       {
11791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11792       };
11793     } catch (Dali::DaliException e) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11796       };
11797     } catch (...) {
11798       {
11799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11800       };
11801     }
11802   }
11803
11804 }
11805
11806
11807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11808   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11809
11810   arg1 = (Dali::Quaternion *)jarg1;
11811   {
11812     try {
11813       (arg1)->Invert();
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11821       };
11822     } catch (Dali::DaliException e) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11825       };
11826     } catch (...) {
11827       {
11828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11829       };
11830     }
11831   }
11832
11833 }
11834
11835
11836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11837   void * jresult ;
11838   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11839   Dali::Quaternion result;
11840
11841   arg1 = (Dali::Quaternion *)jarg1;
11842   {
11843     try {
11844       result = ((Dali::Quaternion const *)arg1)->Log();
11845     } catch (std::out_of_range& e) {
11846       {
11847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11848       };
11849     } catch (std::exception& e) {
11850       {
11851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11852       };
11853     } catch (Dali::DaliException e) {
11854       {
11855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11856       };
11857     } catch (...) {
11858       {
11859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11860       };
11861     }
11862   }
11863
11864   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11865   return jresult;
11866 }
11867
11868
11869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11870   void * jresult ;
11871   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11872   Dali::Quaternion result;
11873
11874   arg1 = (Dali::Quaternion *)jarg1;
11875   {
11876     try {
11877       result = ((Dali::Quaternion const *)arg1)->Exp();
11878     } catch (std::out_of_range& e) {
11879       {
11880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (std::exception& e) {
11883       {
11884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11885       };
11886     } catch (Dali::DaliException e) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11889       };
11890     } catch (...) {
11891       {
11892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11893       };
11894     }
11895   }
11896
11897   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11898   return jresult;
11899 }
11900
11901
11902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11903   float jresult ;
11904   Dali::Quaternion *arg1 = 0 ;
11905   Dali::Quaternion *arg2 = 0 ;
11906   float result;
11907
11908   arg1 = (Dali::Quaternion *)jarg1;
11909   if (!arg1) {
11910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11911     return 0;
11912   }
11913   arg2 = (Dali::Quaternion *)jarg2;
11914   if (!arg2) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11916     return 0;
11917   }
11918   {
11919     try {
11920       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (Dali::DaliException e) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11932       };
11933     } catch (...) {
11934       {
11935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11936       };
11937     }
11938   }
11939
11940   jresult = result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11946   void * jresult ;
11947   Dali::Quaternion *arg1 = 0 ;
11948   Dali::Quaternion *arg2 = 0 ;
11949   float arg3 ;
11950   Dali::Quaternion result;
11951
11952   arg1 = (Dali::Quaternion *)jarg1;
11953   if (!arg1) {
11954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11955     return 0;
11956   }
11957   arg2 = (Dali::Quaternion *)jarg2;
11958   if (!arg2) {
11959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11960     return 0;
11961   }
11962   arg3 = (float)jarg3;
11963   {
11964     try {
11965       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11966     } catch (std::out_of_range& e) {
11967       {
11968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (std::exception& e) {
11971       {
11972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (Dali::DaliException e) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11977       };
11978     } catch (...) {
11979       {
11980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11981       };
11982     }
11983   }
11984
11985   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11991   void * jresult ;
11992   Dali::Quaternion *arg1 = 0 ;
11993   Dali::Quaternion *arg2 = 0 ;
11994   float arg3 ;
11995   Dali::Quaternion result;
11996
11997   arg1 = (Dali::Quaternion *)jarg1;
11998   if (!arg1) {
11999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12000     return 0;
12001   }
12002   arg2 = (Dali::Quaternion *)jarg2;
12003   if (!arg2) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg3 = (float)jarg3;
12008   {
12009     try {
12010       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12011     } catch (std::out_of_range& e) {
12012       {
12013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (std::exception& e) {
12016       {
12017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (Dali::DaliException e) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12022       };
12023     } catch (...) {
12024       {
12025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12026       };
12027     }
12028   }
12029
12030   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12031   return jresult;
12032 }
12033
12034
12035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12036   void * jresult ;
12037   Dali::Quaternion *arg1 = 0 ;
12038   Dali::Quaternion *arg2 = 0 ;
12039   float arg3 ;
12040   Dali::Quaternion result;
12041
12042   arg1 = (Dali::Quaternion *)jarg1;
12043   if (!arg1) {
12044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12045     return 0;
12046   }
12047   arg2 = (Dali::Quaternion *)jarg2;
12048   if (!arg2) {
12049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12050     return 0;
12051   }
12052   arg3 = (float)jarg3;
12053   {
12054     try {
12055       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12056     } catch (std::out_of_range& e) {
12057       {
12058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12059       };
12060     } catch (std::exception& e) {
12061       {
12062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12063       };
12064     } catch (Dali::DaliException e) {
12065       {
12066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12067       };
12068     } catch (...) {
12069       {
12070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12071       };
12072     }
12073   }
12074
12075   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12076   return jresult;
12077 }
12078
12079
12080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12081   void * jresult ;
12082   Dali::Quaternion *arg1 = 0 ;
12083   Dali::Quaternion *arg2 = 0 ;
12084   Dali::Quaternion *arg3 = 0 ;
12085   Dali::Quaternion *arg4 = 0 ;
12086   float arg5 ;
12087   Dali::Quaternion result;
12088
12089   arg1 = (Dali::Quaternion *)jarg1;
12090   if (!arg1) {
12091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12092     return 0;
12093   }
12094   arg2 = (Dali::Quaternion *)jarg2;
12095   if (!arg2) {
12096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12097     return 0;
12098   }
12099   arg3 = (Dali::Quaternion *)jarg3;
12100   if (!arg3) {
12101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12102     return 0;
12103   }
12104   arg4 = (Dali::Quaternion *)jarg4;
12105   if (!arg4) {
12106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12107     return 0;
12108   }
12109   arg5 = (float)jarg5;
12110   {
12111     try {
12112       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12113     } catch (std::out_of_range& e) {
12114       {
12115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (std::exception& e) {
12118       {
12119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12120       };
12121     } catch (Dali::DaliException e) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12124       };
12125     } catch (...) {
12126       {
12127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12128       };
12129     }
12130   }
12131
12132   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12133   return jresult;
12134 }
12135
12136
12137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12138   float jresult ;
12139   Dali::Quaternion *arg1 = 0 ;
12140   Dali::Quaternion *arg2 = 0 ;
12141   float result;
12142
12143   arg1 = (Dali::Quaternion *)jarg1;
12144   if (!arg1) {
12145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12146     return 0;
12147   }
12148   arg2 = (Dali::Quaternion *)jarg2;
12149   if (!arg2) {
12150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12151     return 0;
12152   }
12153   {
12154     try {
12155       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12156     } catch (std::out_of_range& e) {
12157       {
12158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (std::exception& e) {
12161       {
12162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12163       };
12164     } catch (Dali::DaliException e) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12167       };
12168     } catch (...) {
12169       {
12170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12171       };
12172     }
12173   }
12174
12175   jresult = result;
12176   return jresult;
12177 }
12178
12179
12180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12181   void * jresult ;
12182   Dali::Matrix *result = 0 ;
12183
12184   {
12185     try {
12186       result = (Dali::Matrix *)new Dali::Matrix();
12187     } catch (std::out_of_range& e) {
12188       {
12189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12190       };
12191     } catch (std::exception& e) {
12192       {
12193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12194       };
12195     } catch (Dali::DaliException e) {
12196       {
12197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12198       };
12199     } catch (...) {
12200       {
12201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12202       };
12203     }
12204   }
12205
12206   jresult = (void *)result;
12207   return jresult;
12208 }
12209
12210
12211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12212   void * jresult ;
12213   bool arg1 ;
12214   Dali::Matrix *result = 0 ;
12215
12216   arg1 = jarg1 ? true : false;
12217   {
12218     try {
12219       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12220     } catch (std::out_of_range& e) {
12221       {
12222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (std::exception& e) {
12225       {
12226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12227       };
12228     } catch (Dali::DaliException e) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12231       };
12232     } catch (...) {
12233       {
12234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12235       };
12236     }
12237   }
12238
12239   jresult = (void *)result;
12240   return jresult;
12241 }
12242
12243
12244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12245   void * jresult ;
12246   float *arg1 = (float *) 0 ;
12247   Dali::Matrix *result = 0 ;
12248
12249   arg1 = jarg1;
12250   {
12251     try {
12252       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12253     } catch (std::out_of_range& e) {
12254       {
12255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12256       };
12257     } catch (std::exception& e) {
12258       {
12259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12260       };
12261     } catch (Dali::DaliException e) {
12262       {
12263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12264       };
12265     } catch (...) {
12266       {
12267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12268       };
12269     }
12270   }
12271
12272   jresult = (void *)result;
12273
12274
12275   return jresult;
12276 }
12277
12278
12279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12280   void * jresult ;
12281   Dali::Quaternion *arg1 = 0 ;
12282   Dali::Matrix *result = 0 ;
12283
12284   arg1 = (Dali::Quaternion *)jarg1;
12285   if (!arg1) {
12286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12287     return 0;
12288   }
12289   {
12290     try {
12291       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (Dali::DaliException e) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12303       };
12304     } catch (...) {
12305       {
12306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12307       };
12308     }
12309   }
12310
12311   jresult = (void *)result;
12312   return jresult;
12313 }
12314
12315
12316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12317   void * jresult ;
12318   Dali::Matrix *arg1 = 0 ;
12319   Dali::Matrix *result = 0 ;
12320
12321   arg1 = (Dali::Matrix *)jarg1;
12322   if (!arg1) {
12323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12324     return 0;
12325   }
12326   {
12327     try {
12328       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12329     } catch (std::out_of_range& e) {
12330       {
12331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (std::exception& e) {
12334       {
12335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12336       };
12337     } catch (Dali::DaliException e) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12340       };
12341     } catch (...) {
12342       {
12343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12344       };
12345     }
12346   }
12347
12348   jresult = (void *)result;
12349   return jresult;
12350 }
12351
12352
12353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12354   void * jresult ;
12355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12356   Dali::Matrix *arg2 = 0 ;
12357   Dali::Matrix *result = 0 ;
12358
12359   arg1 = (Dali::Matrix *)jarg1;
12360   arg2 = (Dali::Matrix *)jarg2;
12361   if (!arg2) {
12362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12363     return 0;
12364   }
12365   {
12366     try {
12367       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12368     } catch (std::out_of_range& e) {
12369       {
12370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12371       };
12372     } catch (std::exception& e) {
12373       {
12374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12375       };
12376     } catch (Dali::DaliException e) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12379       };
12380     } catch (...) {
12381       {
12382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12383       };
12384     }
12385   }
12386
12387   jresult = (void *)result;
12388   return jresult;
12389 }
12390
12391
12392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12393   void * jresult ;
12394   Dali::Matrix *result = 0 ;
12395
12396   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12397   jresult = (void *)result;
12398   return jresult;
12399 }
12400
12401
12402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12403   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12404
12405   arg1 = (Dali::Matrix *)jarg1;
12406   {
12407     try {
12408       (arg1)->SetIdentity();
12409     } catch (std::out_of_range& e) {
12410       {
12411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12412       };
12413     } catch (std::exception& e) {
12414       {
12415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12416       };
12417     } catch (Dali::DaliException e) {
12418       {
12419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12420       };
12421     } catch (...) {
12422       {
12423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12424       };
12425     }
12426   }
12427
12428 }
12429
12430
12431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12432   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12433   Dali::Vector3 *arg2 = 0 ;
12434
12435   arg1 = (Dali::Matrix *)jarg1;
12436   arg2 = (Dali::Vector3 *)jarg2;
12437   if (!arg2) {
12438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12439     return ;
12440   }
12441   {
12442     try {
12443       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12444     } catch (std::out_of_range& e) {
12445       {
12446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12447       };
12448     } catch (std::exception& e) {
12449       {
12450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12451       };
12452     } catch (Dali::DaliException e) {
12453       {
12454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12455       };
12456     } catch (...) {
12457       {
12458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12459       };
12460     }
12461   }
12462
12463 }
12464
12465
12466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12467   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12468   Dali::Matrix *arg2 = 0 ;
12469
12470   arg1 = (Dali::Matrix *)jarg1;
12471   arg2 = (Dali::Matrix *)jarg2;
12472   if (!arg2) {
12473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12474     return ;
12475   }
12476   {
12477     try {
12478       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12479     } catch (std::out_of_range& e) {
12480       {
12481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12482       };
12483     } catch (std::exception& e) {
12484       {
12485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12486       };
12487     } catch (Dali::DaliException e) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12490       };
12491     } catch (...) {
12492       {
12493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12494       };
12495     }
12496   }
12497
12498 }
12499
12500
12501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12502   unsigned int jresult ;
12503   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12504   bool result;
12505
12506   arg1 = (Dali::Matrix *)jarg1;
12507   {
12508     try {
12509       result = (bool)(arg1)->Invert();
12510     } catch (std::out_of_range& e) {
12511       {
12512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (std::exception& e) {
12515       {
12516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12517       };
12518     } catch (Dali::DaliException e) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12521       };
12522     } catch (...) {
12523       {
12524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12525       };
12526     }
12527   }
12528
12529   jresult = result;
12530   return jresult;
12531 }
12532
12533
12534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12535   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12536
12537   arg1 = (Dali::Matrix *)jarg1;
12538   {
12539     try {
12540       (arg1)->Transpose();
12541     } catch (std::out_of_range& e) {
12542       {
12543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12544       };
12545     } catch (std::exception& e) {
12546       {
12547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12548       };
12549     } catch (Dali::DaliException e) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12552       };
12553     } catch (...) {
12554       {
12555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12556       };
12557     }
12558   }
12559
12560 }
12561
12562
12563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12564   void * jresult ;
12565   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12566   Dali::Vector3 result;
12567
12568   arg1 = (Dali::Matrix *)jarg1;
12569   {
12570     try {
12571       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12572     } catch (std::out_of_range& e) {
12573       {
12574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (std::exception& e) {
12577       {
12578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12579       };
12580     } catch (Dali::DaliException e) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12583       };
12584     } catch (...) {
12585       {
12586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12587       };
12588     }
12589   }
12590
12591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12592   return jresult;
12593 }
12594
12595
12596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12597   void * jresult ;
12598   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12599   Dali::Vector3 result;
12600
12601   arg1 = (Dali::Matrix *)jarg1;
12602   {
12603     try {
12604       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12605     } catch (std::out_of_range& e) {
12606       {
12607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12608       };
12609     } catch (std::exception& e) {
12610       {
12611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12612       };
12613     } catch (Dali::DaliException e) {
12614       {
12615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12616       };
12617     } catch (...) {
12618       {
12619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12620       };
12621     }
12622   }
12623
12624   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12625   return jresult;
12626 }
12627
12628
12629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12630   void * jresult ;
12631   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12632   Dali::Vector3 result;
12633
12634   arg1 = (Dali::Matrix *)jarg1;
12635   {
12636     try {
12637       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12638     } catch (std::out_of_range& e) {
12639       {
12640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12641       };
12642     } catch (std::exception& e) {
12643       {
12644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12645       };
12646     } catch (Dali::DaliException e) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12653       };
12654     }
12655   }
12656
12657   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12658   return jresult;
12659 }
12660
12661
12662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12663   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12664   Dali::Vector3 *arg2 = 0 ;
12665
12666   arg1 = (Dali::Matrix *)jarg1;
12667   arg2 = (Dali::Vector3 *)jarg2;
12668   if (!arg2) {
12669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12670     return ;
12671   }
12672   {
12673     try {
12674       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12675     } catch (std::out_of_range& e) {
12676       {
12677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12678       };
12679     } catch (std::exception& e) {
12680       {
12681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12682       };
12683     } catch (Dali::DaliException e) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12686       };
12687     } catch (...) {
12688       {
12689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12690       };
12691     }
12692   }
12693
12694 }
12695
12696
12697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12698   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12699   Dali::Vector3 *arg2 = 0 ;
12700
12701   arg1 = (Dali::Matrix *)jarg1;
12702   arg2 = (Dali::Vector3 *)jarg2;
12703   if (!arg2) {
12704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12705     return ;
12706   }
12707   {
12708     try {
12709       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12710     } catch (std::out_of_range& e) {
12711       {
12712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12713       };
12714     } catch (std::exception& e) {
12715       {
12716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12717       };
12718     } catch (Dali::DaliException e) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12721       };
12722     } catch (...) {
12723       {
12724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12725       };
12726     }
12727   }
12728
12729 }
12730
12731
12732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12733   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12734   Dali::Vector3 *arg2 = 0 ;
12735
12736   arg1 = (Dali::Matrix *)jarg1;
12737   arg2 = (Dali::Vector3 *)jarg2;
12738   if (!arg2) {
12739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12740     return ;
12741   }
12742   {
12743     try {
12744       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12745     } catch (std::out_of_range& e) {
12746       {
12747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12748       };
12749     } catch (std::exception& e) {
12750       {
12751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12752       };
12753     } catch (Dali::DaliException e) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12756       };
12757     } catch (...) {
12758       {
12759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12760       };
12761     }
12762   }
12763
12764 }
12765
12766
12767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12768   void * jresult ;
12769   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12770   Dali::Vector4 *result = 0 ;
12771
12772   arg1 = (Dali::Matrix *)jarg1;
12773   {
12774     try {
12775       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12776     } catch (std::out_of_range& e) {
12777       {
12778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12779       };
12780     } catch (std::exception& e) {
12781       {
12782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12783       };
12784     } catch (Dali::DaliException e) {
12785       {
12786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12787       };
12788     } catch (...) {
12789       {
12790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12791       };
12792     }
12793   }
12794
12795   jresult = (void *)result;
12796   return jresult;
12797 }
12798
12799
12800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12801   void * jresult ;
12802   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12803   Dali::Vector3 *result = 0 ;
12804
12805   arg1 = (Dali::Matrix *)jarg1;
12806   {
12807     try {
12808       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12809     } catch (std::out_of_range& e) {
12810       {
12811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (std::exception& e) {
12814       {
12815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12816       };
12817     } catch (Dali::DaliException e) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12820       };
12821     } catch (...) {
12822       {
12823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12824       };
12825     }
12826   }
12827
12828   jresult = (void *)result;
12829   return jresult;
12830 }
12831
12832
12833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12834   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12835   Dali::Vector4 *arg2 = 0 ;
12836
12837   arg1 = (Dali::Matrix *)jarg1;
12838   arg2 = (Dali::Vector4 *)jarg2;
12839   if (!arg2) {
12840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12841     return ;
12842   }
12843   {
12844     try {
12845       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12846     } catch (std::out_of_range& e) {
12847       {
12848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12849       };
12850     } catch (std::exception& e) {
12851       {
12852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12853       };
12854     } catch (Dali::DaliException e) {
12855       {
12856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12857       };
12858     } catch (...) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12861       };
12862     }
12863   }
12864
12865 }
12866
12867
12868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12869   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12870   Dali::Vector3 *arg2 = 0 ;
12871
12872   arg1 = (Dali::Matrix *)jarg1;
12873   arg2 = (Dali::Vector3 *)jarg2;
12874   if (!arg2) {
12875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12876     return ;
12877   }
12878   {
12879     try {
12880       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12881     } catch (std::out_of_range& e) {
12882       {
12883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12884       };
12885     } catch (std::exception& e) {
12886       {
12887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12888       };
12889     } catch (Dali::DaliException e) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12892       };
12893     } catch (...) {
12894       {
12895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12896       };
12897     }
12898   }
12899
12900 }
12901
12902
12903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12904   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12905
12906   arg1 = (Dali::Matrix *)jarg1;
12907   {
12908     try {
12909       (arg1)->OrthoNormalize();
12910     } catch (std::out_of_range& e) {
12911       {
12912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12913       };
12914     } catch (std::exception& e) {
12915       {
12916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12917       };
12918     } catch (Dali::DaliException e) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12921       };
12922     } catch (...) {
12923       {
12924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12925       };
12926     }
12927   }
12928
12929 }
12930
12931
12932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12933   void * jresult ;
12934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12935   float *result = 0 ;
12936
12937   arg1 = (Dali::Matrix *)jarg1;
12938   {
12939     try {
12940       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12941     } catch (std::out_of_range& e) {
12942       {
12943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12944       };
12945     } catch (std::exception& e) {
12946       {
12947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12948       };
12949     } catch (Dali::DaliException e) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12952       };
12953     } catch (...) {
12954       {
12955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12956       };
12957     }
12958   }
12959
12960   jresult = (void *)result;
12961   return jresult;
12962 }
12963
12964
12965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12966   Dali::Matrix *arg1 = 0 ;
12967   Dali::Matrix *arg2 = 0 ;
12968   Dali::Matrix *arg3 = 0 ;
12969
12970   arg1 = (Dali::Matrix *)jarg1;
12971   if (!arg1) {
12972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12973     return ;
12974   }
12975   arg2 = (Dali::Matrix *)jarg2;
12976   if (!arg2) {
12977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12978     return ;
12979   }
12980   arg3 = (Dali::Matrix *)jarg3;
12981   if (!arg3) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12983     return ;
12984   }
12985   {
12986     try {
12987       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12988     } catch (std::out_of_range& e) {
12989       {
12990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (std::exception& e) {
12993       {
12994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12995       };
12996     } catch (Dali::DaliException e) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12999       };
13000     } catch (...) {
13001       {
13002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13003       };
13004     }
13005   }
13006
13007 }
13008
13009
13010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13011   Dali::Matrix *arg1 = 0 ;
13012   Dali::Matrix *arg2 = 0 ;
13013   Dali::Quaternion *arg3 = 0 ;
13014
13015   arg1 = (Dali::Matrix *)jarg1;
13016   if (!arg1) {
13017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13018     return ;
13019   }
13020   arg2 = (Dali::Matrix *)jarg2;
13021   if (!arg2) {
13022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13023     return ;
13024   }
13025   arg3 = (Dali::Quaternion *)jarg3;
13026   if (!arg3) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13028     return ;
13029   }
13030   {
13031     try {
13032       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13033     } catch (std::out_of_range& e) {
13034       {
13035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13036       };
13037     } catch (std::exception& e) {
13038       {
13039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13040       };
13041     } catch (Dali::DaliException e) {
13042       {
13043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13044       };
13045     } catch (...) {
13046       {
13047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13048       };
13049     }
13050   }
13051
13052 }
13053
13054
13055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13056   void * jresult ;
13057   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13058   Dali::Vector4 *arg2 = 0 ;
13059   Dali::Vector4 result;
13060
13061   arg1 = (Dali::Matrix *)jarg1;
13062   arg2 = (Dali::Vector4 *)jarg2;
13063   if (!arg2) {
13064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13065     return 0;
13066   }
13067   {
13068     try {
13069       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (Dali::DaliException e) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13081       };
13082     } catch (...) {
13083       {
13084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13085       };
13086     }
13087   }
13088
13089   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13090   return jresult;
13091 }
13092
13093
13094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13095   unsigned int jresult ;
13096   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13097   Dali::Matrix *arg2 = 0 ;
13098   bool result;
13099
13100   arg1 = (Dali::Matrix *)jarg1;
13101   arg2 = (Dali::Matrix *)jarg2;
13102   if (!arg2) {
13103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13104     return 0;
13105   }
13106   {
13107     try {
13108       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13109     } catch (std::out_of_range& e) {
13110       {
13111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (std::exception& e) {
13114       {
13115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13116       };
13117     } catch (Dali::DaliException e) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13120       };
13121     } catch (...) {
13122       {
13123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13124       };
13125     }
13126   }
13127
13128   jresult = result;
13129   return jresult;
13130 }
13131
13132
13133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13134   unsigned int jresult ;
13135   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13136   Dali::Matrix *arg2 = 0 ;
13137   bool result;
13138
13139   arg1 = (Dali::Matrix *)jarg1;
13140   arg2 = (Dali::Matrix *)jarg2;
13141   if (!arg2) {
13142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13143     return 0;
13144   }
13145   {
13146     try {
13147       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13148     } catch (std::out_of_range& e) {
13149       {
13150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13151       };
13152     } catch (std::exception& e) {
13153       {
13154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13155       };
13156     } catch (Dali::DaliException e) {
13157       {
13158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13159       };
13160     } catch (...) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13163       };
13164     }
13165   }
13166
13167   jresult = result;
13168   return jresult;
13169 }
13170
13171
13172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13173   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13174   Dali::Vector3 *arg2 = 0 ;
13175   Dali::Quaternion *arg3 = 0 ;
13176   Dali::Vector3 *arg4 = 0 ;
13177
13178   arg1 = (Dali::Matrix *)jarg1;
13179   arg2 = (Dali::Vector3 *)jarg2;
13180   if (!arg2) {
13181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13182     return ;
13183   }
13184   arg3 = (Dali::Quaternion *)jarg3;
13185   if (!arg3) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13187     return ;
13188   }
13189   arg4 = (Dali::Vector3 *)jarg4;
13190   if (!arg4) {
13191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13192     return ;
13193   }
13194   {
13195     try {
13196       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13197     } catch (std::out_of_range& e) {
13198       {
13199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (std::exception& e) {
13202       {
13203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13204       };
13205     } catch (Dali::DaliException e) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13208       };
13209     } catch (...) {
13210       {
13211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13212       };
13213     }
13214   }
13215
13216 }
13217
13218
13219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13220   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13221   Dali::Vector3 *arg2 = 0 ;
13222   Dali::Quaternion *arg3 = 0 ;
13223   Dali::Vector3 *arg4 = 0 ;
13224
13225   arg1 = (Dali::Matrix *)jarg1;
13226   arg2 = (Dali::Vector3 *)jarg2;
13227   if (!arg2) {
13228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13229     return ;
13230   }
13231   arg3 = (Dali::Quaternion *)jarg3;
13232   if (!arg3) {
13233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13234     return ;
13235   }
13236   arg4 = (Dali::Vector3 *)jarg4;
13237   if (!arg4) {
13238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13239     return ;
13240   }
13241   {
13242     try {
13243       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13244     } catch (std::out_of_range& e) {
13245       {
13246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13247       };
13248     } catch (std::exception& e) {
13249       {
13250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13251       };
13252     } catch (Dali::DaliException e) {
13253       {
13254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13255       };
13256     } catch (...) {
13257       {
13258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13259       };
13260     }
13261   }
13262
13263 }
13264
13265
13266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13267   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13268   Dali::Vector3 *arg2 = 0 ;
13269   Dali::Vector3 *arg3 = 0 ;
13270   Dali::Vector3 *arg4 = 0 ;
13271   Dali::Vector3 *arg5 = 0 ;
13272
13273   arg1 = (Dali::Matrix *)jarg1;
13274   arg2 = (Dali::Vector3 *)jarg2;
13275   if (!arg2) {
13276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13277     return ;
13278   }
13279   arg3 = (Dali::Vector3 *)jarg3;
13280   if (!arg3) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13282     return ;
13283   }
13284   arg4 = (Dali::Vector3 *)jarg4;
13285   if (!arg4) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13287     return ;
13288   }
13289   arg5 = (Dali::Vector3 *)jarg5;
13290   if (!arg5) {
13291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13292     return ;
13293   }
13294   {
13295     try {
13296       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13297     } catch (std::out_of_range& e) {
13298       {
13299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (std::exception& e) {
13302       {
13303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13304       };
13305     } catch (Dali::DaliException e) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13308       };
13309     } catch (...) {
13310       {
13311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13312       };
13313     }
13314   }
13315
13316 }
13317
13318
13319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13320   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13321   Dali::Vector3 *arg2 = 0 ;
13322   Dali::Quaternion *arg3 = 0 ;
13323   Dali::Vector3 *arg4 = 0 ;
13324
13325   arg1 = (Dali::Matrix *)jarg1;
13326   arg2 = (Dali::Vector3 *)jarg2;
13327   if (!arg2) {
13328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13329     return ;
13330   }
13331   arg3 = (Dali::Quaternion *)jarg3;
13332   if (!arg3) {
13333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13334     return ;
13335   }
13336   arg4 = (Dali::Vector3 *)jarg4;
13337   if (!arg4) {
13338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13339     return ;
13340   }
13341   {
13342     try {
13343       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13344     } catch (std::out_of_range& e) {
13345       {
13346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13347       };
13348     } catch (std::exception& e) {
13349       {
13350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13351       };
13352     } catch (Dali::DaliException e) {
13353       {
13354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13355       };
13356     } catch (...) {
13357       {
13358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13359       };
13360     }
13361   }
13362
13363 }
13364
13365
13366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13367   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13368
13369   arg1 = (Dali::Matrix *)jarg1;
13370   {
13371     try {
13372       delete arg1;
13373     } catch (std::out_of_range& e) {
13374       {
13375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13376       };
13377     } catch (std::exception& e) {
13378       {
13379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13380       };
13381     } catch (Dali::DaliException e) {
13382       {
13383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13384       };
13385     } catch (...) {
13386       {
13387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13388       };
13389     }
13390   }
13391
13392 }
13393
13394
13395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13396   void * jresult ;
13397   Dali::Matrix3 *result = 0 ;
13398
13399   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13400   jresult = (void *)result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13406   void * jresult ;
13407   Dali::Matrix3 *result = 0 ;
13408
13409   {
13410     try {
13411       result = (Dali::Matrix3 *)new Dali::Matrix3();
13412     } catch (std::out_of_range& e) {
13413       {
13414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13415       };
13416     } catch (std::exception& e) {
13417       {
13418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (Dali::DaliException e) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13423       };
13424     } catch (...) {
13425       {
13426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13427       };
13428     }
13429   }
13430
13431   jresult = (void *)result;
13432   return jresult;
13433 }
13434
13435
13436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13437   void * jresult ;
13438   Dali::Matrix3 *arg1 = 0 ;
13439   Dali::Matrix3 *result = 0 ;
13440
13441   arg1 = (Dali::Matrix3 *)jarg1;
13442   if (!arg1) {
13443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13444     return 0;
13445   }
13446   {
13447     try {
13448       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13449     } catch (std::out_of_range& e) {
13450       {
13451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13452       };
13453     } catch (std::exception& e) {
13454       {
13455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13456       };
13457     } catch (Dali::DaliException e) {
13458       {
13459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13460       };
13461     } catch (...) {
13462       {
13463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13464       };
13465     }
13466   }
13467
13468   jresult = (void *)result;
13469   return jresult;
13470 }
13471
13472
13473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13474   void * jresult ;
13475   Dali::Matrix *arg1 = 0 ;
13476   Dali::Matrix3 *result = 0 ;
13477
13478   arg1 = (Dali::Matrix *)jarg1;
13479   if (!arg1) {
13480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13481     return 0;
13482   }
13483   {
13484     try {
13485       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13486     } catch (std::out_of_range& e) {
13487       {
13488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (std::exception& e) {
13491       {
13492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (Dali::DaliException e) {
13495       {
13496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13497       };
13498     } catch (...) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13501       };
13502     }
13503   }
13504
13505   jresult = (void *)result;
13506   return jresult;
13507 }
13508
13509
13510 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) {
13511   void * jresult ;
13512   float arg1 ;
13513   float arg2 ;
13514   float arg3 ;
13515   float arg4 ;
13516   float arg5 ;
13517   float arg6 ;
13518   float arg7 ;
13519   float arg8 ;
13520   float arg9 ;
13521   Dali::Matrix3 *result = 0 ;
13522
13523   arg1 = (float)jarg1;
13524   arg2 = (float)jarg2;
13525   arg3 = (float)jarg3;
13526   arg4 = (float)jarg4;
13527   arg5 = (float)jarg5;
13528   arg6 = (float)jarg6;
13529   arg7 = (float)jarg7;
13530   arg8 = (float)jarg8;
13531   arg9 = (float)jarg9;
13532   {
13533     try {
13534       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13535     } catch (std::out_of_range& e) {
13536       {
13537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (std::exception& e) {
13540       {
13541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13542       };
13543     } catch (Dali::DaliException e) {
13544       {
13545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13546       };
13547     } catch (...) {
13548       {
13549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13550       };
13551     }
13552   }
13553
13554   jresult = (void *)result;
13555   return jresult;
13556 }
13557
13558
13559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13560   void * jresult ;
13561   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13562   Dali::Matrix3 *arg2 = 0 ;
13563   Dali::Matrix3 *result = 0 ;
13564
13565   arg1 = (Dali::Matrix3 *)jarg1;
13566   arg2 = (Dali::Matrix3 *)jarg2;
13567   if (!arg2) {
13568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13569     return 0;
13570   }
13571   {
13572     try {
13573       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13574     } catch (std::out_of_range& e) {
13575       {
13576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13577       };
13578     } catch (std::exception& e) {
13579       {
13580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13581       };
13582     } catch (Dali::DaliException e) {
13583       {
13584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13585       };
13586     } catch (...) {
13587       {
13588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13589       };
13590     }
13591   }
13592
13593   jresult = (void *)result;
13594   return jresult;
13595 }
13596
13597
13598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13599   void * jresult ;
13600   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13601   Dali::Matrix *arg2 = 0 ;
13602   Dali::Matrix3 *result = 0 ;
13603
13604   arg1 = (Dali::Matrix3 *)jarg1;
13605   arg2 = (Dali::Matrix *)jarg2;
13606   if (!arg2) {
13607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13608     return 0;
13609   }
13610   {
13611     try {
13612       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13613     } catch (std::out_of_range& e) {
13614       {
13615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13616       };
13617     } catch (std::exception& e) {
13618       {
13619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13620       };
13621     } catch (Dali::DaliException e) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13624       };
13625     } catch (...) {
13626       {
13627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13628       };
13629     }
13630   }
13631
13632   jresult = (void *)result;
13633   return jresult;
13634 }
13635
13636
13637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13638   unsigned int jresult ;
13639   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13640   Dali::Matrix3 *arg2 = 0 ;
13641   bool result;
13642
13643   arg1 = (Dali::Matrix3 *)jarg1;
13644   arg2 = (Dali::Matrix3 *)jarg2;
13645   if (!arg2) {
13646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13647     return 0;
13648   }
13649   {
13650     try {
13651       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13652     } catch (std::out_of_range& e) {
13653       {
13654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13655       };
13656     } catch (std::exception& e) {
13657       {
13658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13659       };
13660     } catch (Dali::DaliException e) {
13661       {
13662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13663       };
13664     } catch (...) {
13665       {
13666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13667       };
13668     }
13669   }
13670
13671   jresult = result;
13672   return jresult;
13673 }
13674
13675
13676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13677   unsigned int jresult ;
13678   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13679   Dali::Matrix3 *arg2 = 0 ;
13680   bool result;
13681
13682   arg1 = (Dali::Matrix3 *)jarg1;
13683   arg2 = (Dali::Matrix3 *)jarg2;
13684   if (!arg2) {
13685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13686     return 0;
13687   }
13688   {
13689     try {
13690       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13691     } catch (std::out_of_range& e) {
13692       {
13693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13694       };
13695     } catch (std::exception& e) {
13696       {
13697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13698       };
13699     } catch (Dali::DaliException e) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13702       };
13703     } catch (...) {
13704       {
13705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13706       };
13707     }
13708   }
13709
13710   jresult = result;
13711   return jresult;
13712 }
13713
13714
13715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13716   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13717
13718   arg1 = (Dali::Matrix3 *)jarg1;
13719   {
13720     try {
13721       delete arg1;
13722     } catch (std::out_of_range& e) {
13723       {
13724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13725       };
13726     } catch (std::exception& e) {
13727       {
13728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13729       };
13730     } catch (Dali::DaliException e) {
13731       {
13732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13733       };
13734     } catch (...) {
13735       {
13736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13737       };
13738     }
13739   }
13740
13741 }
13742
13743
13744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13745   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13746
13747   arg1 = (Dali::Matrix3 *)jarg1;
13748   {
13749     try {
13750       (arg1)->SetIdentity();
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13758       };
13759     } catch (Dali::DaliException e) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13762       };
13763     } catch (...) {
13764       {
13765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13766       };
13767     }
13768   }
13769
13770 }
13771
13772
13773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13774   void * jresult ;
13775   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13776   float *result = 0 ;
13777
13778   arg1 = (Dali::Matrix3 *)jarg1;
13779   {
13780     try {
13781       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13782     } catch (std::out_of_range& e) {
13783       {
13784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (std::exception& e) {
13787       {
13788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13789       };
13790     } catch (Dali::DaliException e) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13793       };
13794     } catch (...) {
13795       {
13796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13797       };
13798     }
13799   }
13800
13801   jresult = (void *)result;
13802   return jresult;
13803 }
13804
13805
13806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13807   unsigned int jresult ;
13808   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13809   bool result;
13810
13811   arg1 = (Dali::Matrix3 *)jarg1;
13812   {
13813     try {
13814       result = (bool)(arg1)->Invert();
13815     } catch (std::out_of_range& e) {
13816       {
13817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (std::exception& e) {
13820       {
13821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13822       };
13823     } catch (Dali::DaliException e) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13826       };
13827     } catch (...) {
13828       {
13829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13830       };
13831     }
13832   }
13833
13834   jresult = result;
13835   return jresult;
13836 }
13837
13838
13839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13840   unsigned int jresult ;
13841   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13842   bool result;
13843
13844   arg1 = (Dali::Matrix3 *)jarg1;
13845   {
13846     try {
13847       result = (bool)(arg1)->Transpose();
13848     } catch (std::out_of_range& e) {
13849       {
13850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13851       };
13852     } catch (std::exception& e) {
13853       {
13854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13855       };
13856     } catch (Dali::DaliException e) {
13857       {
13858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13859       };
13860     } catch (...) {
13861       {
13862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13863       };
13864     }
13865   }
13866
13867   jresult = result;
13868   return jresult;
13869 }
13870
13871
13872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13873   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13874   float arg2 ;
13875
13876   arg1 = (Dali::Matrix3 *)jarg1;
13877   arg2 = (float)jarg2;
13878   {
13879     try {
13880       (arg1)->Scale(arg2);
13881     } catch (std::out_of_range& e) {
13882       {
13883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13884       };
13885     } catch (std::exception& e) {
13886       {
13887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13888       };
13889     } catch (Dali::DaliException e) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13896       };
13897     }
13898   }
13899
13900 }
13901
13902
13903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13904   float jresult ;
13905   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13906   float result;
13907
13908   arg1 = (Dali::Matrix3 *)jarg1;
13909   {
13910     try {
13911       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13912     } catch (std::out_of_range& e) {
13913       {
13914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13915       };
13916     } catch (std::exception& e) {
13917       {
13918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13919       };
13920     } catch (Dali::DaliException e) {
13921       {
13922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13923       };
13924     } catch (...) {
13925       {
13926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13927       };
13928     }
13929   }
13930
13931   jresult = result;
13932   return jresult;
13933 }
13934
13935
13936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13937   unsigned int jresult ;
13938   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13939   bool result;
13940
13941   arg1 = (Dali::Matrix3 *)jarg1;
13942   {
13943     try {
13944       result = (bool)(arg1)->ScaledInverseTranspose();
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13952       };
13953     } catch (Dali::DaliException e) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13956       };
13957     } catch (...) {
13958       {
13959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13960       };
13961     }
13962   }
13963
13964   jresult = result;
13965   return jresult;
13966 }
13967
13968
13969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13970   Dali::Matrix3 *arg1 = 0 ;
13971   Dali::Matrix3 *arg2 = 0 ;
13972   Dali::Matrix3 *arg3 = 0 ;
13973
13974   arg1 = (Dali::Matrix3 *)jarg1;
13975   if (!arg1) {
13976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13977     return ;
13978   }
13979   arg2 = (Dali::Matrix3 *)jarg2;
13980   if (!arg2) {
13981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13982     return ;
13983   }
13984   arg3 = (Dali::Matrix3 *)jarg3;
13985   if (!arg3) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13987     return ;
13988   }
13989   {
13990     try {
13991       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13992     } catch (std::out_of_range& e) {
13993       {
13994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13995       };
13996     } catch (std::exception& e) {
13997       {
13998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13999       };
14000     } catch (Dali::DaliException e) {
14001       {
14002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14003       };
14004     } catch (...) {
14005       {
14006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14007       };
14008     }
14009   }
14010
14011 }
14012
14013
14014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14015   float jresult ;
14016   float arg1 ;
14017   float arg2 ;
14018   float result;
14019
14020   arg1 = (float)jarg1;
14021   arg2 = (float)jarg2;
14022   {
14023     try {
14024       result = (float)Dali::Random::Range(arg1,arg2);
14025     } catch (std::out_of_range& e) {
14026       {
14027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (std::exception& e) {
14030       {
14031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14032       };
14033     } catch (Dali::DaliException e) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14036       };
14037     } catch (...) {
14038       {
14039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14040       };
14041     }
14042   }
14043
14044   jresult = result;
14045   return jresult;
14046 }
14047
14048
14049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14050   void * jresult ;
14051   Dali::Vector4 result;
14052
14053   {
14054     try {
14055       result = Dali::Random::Axis();
14056     } catch (std::out_of_range& e) {
14057       {
14058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (std::exception& e) {
14061       {
14062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14063       };
14064     } catch (Dali::DaliException e) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14067       };
14068     } catch (...) {
14069       {
14070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14071       };
14072     }
14073   }
14074
14075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14076   return jresult;
14077 }
14078
14079
14080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14081   void * jresult ;
14082   Dali::AngleAxis *result = 0 ;
14083
14084   {
14085     try {
14086       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14087     } catch (std::out_of_range& e) {
14088       {
14089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (std::exception& e) {
14092       {
14093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14094       };
14095     } catch (Dali::DaliException e) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14098       };
14099     } catch (...) {
14100       {
14101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14102       };
14103     }
14104   }
14105
14106   jresult = (void *)result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14112   void * jresult ;
14113   Dali::Radian arg1 ;
14114   Dali::Vector3 *arg2 = 0 ;
14115   Dali::Radian *argp1 ;
14116   Dali::AngleAxis *result = 0 ;
14117
14118   argp1 = (Dali::Radian *)jarg1;
14119   if (!argp1) {
14120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14121     return 0;
14122   }
14123   arg1 = *argp1;
14124   arg2 = (Dali::Vector3 *)jarg2;
14125   if (!arg2) {
14126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14127     return 0;
14128   }
14129   {
14130     try {
14131       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14132     } catch (std::out_of_range& e) {
14133       {
14134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14135       };
14136     } catch (std::exception& e) {
14137       {
14138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14139       };
14140     } catch (Dali::DaliException e) {
14141       {
14142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14143       };
14144     } catch (...) {
14145       {
14146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14147       };
14148     }
14149   }
14150
14151   jresult = (void *)result;
14152   return jresult;
14153 }
14154
14155
14156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14157   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14158   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14159
14160   arg1 = (Dali::AngleAxis *)jarg1;
14161   arg2 = (Dali::Radian *)jarg2;
14162   if (arg1) (arg1)->angle = *arg2;
14163 }
14164
14165
14166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14167   void * jresult ;
14168   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14169   Dali::Radian *result = 0 ;
14170
14171   arg1 = (Dali::AngleAxis *)jarg1;
14172   result = (Dali::Radian *)& ((arg1)->angle);
14173   jresult = (void *)result;
14174   return jresult;
14175 }
14176
14177
14178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14179   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14180   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14181
14182   arg1 = (Dali::AngleAxis *)jarg1;
14183   arg2 = (Dali::Vector3 *)jarg2;
14184   if (arg1) (arg1)->axis = *arg2;
14185 }
14186
14187
14188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14189   void * jresult ;
14190   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14191   Dali::Vector3 *result = 0 ;
14192
14193   arg1 = (Dali::AngleAxis *)jarg1;
14194   result = (Dali::Vector3 *)& ((arg1)->axis);
14195   jresult = (void *)result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14201   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14202
14203   arg1 = (Dali::AngleAxis *)jarg1;
14204   {
14205     try {
14206       delete arg1;
14207     } catch (std::out_of_range& e) {
14208       {
14209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14210       };
14211     } catch (std::exception& e) {
14212       {
14213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14214       };
14215     } catch (Dali::DaliException e) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14218       };
14219     } catch (...) {
14220       {
14221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14222       };
14223     }
14224   }
14225
14226 }
14227
14228
14229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14230   unsigned int jresult ;
14231   Dali::AngleAxis *arg1 = 0 ;
14232   Dali::AngleAxis *arg2 = 0 ;
14233   bool result;
14234
14235   arg1 = (Dali::AngleAxis *)jarg1;
14236   if (!arg1) {
14237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14238     return 0;
14239   }
14240   arg2 = (Dali::AngleAxis *)jarg2;
14241   if (!arg2) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14243     return 0;
14244   }
14245   {
14246     try {
14247       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14255       };
14256     } catch (Dali::DaliException e) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14259       };
14260     } catch (...) {
14261       {
14262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14263       };
14264     }
14265   }
14266
14267   jresult = result;
14268   return jresult;
14269 }
14270
14271
14272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14273   unsigned int jresult ;
14274   unsigned int arg1 ;
14275   unsigned int result;
14276
14277   arg1 = (unsigned int)jarg1;
14278   {
14279     try {
14280       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14281     } catch (std::out_of_range& e) {
14282       {
14283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (std::exception& e) {
14286       {
14287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14288       };
14289     } catch (Dali::DaliException e) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14292       };
14293     } catch (...) {
14294       {
14295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14296       };
14297     }
14298   }
14299
14300   jresult = result;
14301   return jresult;
14302 }
14303
14304
14305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14306   unsigned int jresult ;
14307   unsigned int arg1 ;
14308   bool result;
14309
14310   arg1 = (unsigned int)jarg1;
14311   {
14312     try {
14313       result = (bool)Dali::IsPowerOfTwo(arg1);
14314     } catch (std::out_of_range& e) {
14315       {
14316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (std::exception& e) {
14319       {
14320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (Dali::DaliException e) {
14323       {
14324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332
14333   jresult = result;
14334   return jresult;
14335 }
14336
14337
14338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14339   float jresult ;
14340   float arg1 ;
14341   float arg2 ;
14342   float result;
14343
14344   arg1 = (float)jarg1;
14345   arg2 = (float)jarg2;
14346   {
14347     try {
14348       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14349     } catch (std::out_of_range& e) {
14350       {
14351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (std::exception& e) {
14354       {
14355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14356       };
14357     } catch (Dali::DaliException e) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14360       };
14361     } catch (...) {
14362       {
14363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14364       };
14365     }
14366   }
14367
14368   jresult = result;
14369   return jresult;
14370 }
14371
14372
14373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14374   unsigned int jresult ;
14375   float arg1 ;
14376   bool result;
14377
14378   arg1 = (float)jarg1;
14379   {
14380     try {
14381       result = (bool)Dali::EqualsZero(arg1);
14382     } catch (std::out_of_range& e) {
14383       {
14384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (std::exception& e) {
14387       {
14388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (Dali::DaliException e) {
14391       {
14392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14393       };
14394     } catch (...) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14397       };
14398     }
14399   }
14400
14401   jresult = result;
14402   return jresult;
14403 }
14404
14405
14406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14407   unsigned int jresult ;
14408   float arg1 ;
14409   float arg2 ;
14410   bool result;
14411
14412   arg1 = (float)jarg1;
14413   arg2 = (float)jarg2;
14414   {
14415     try {
14416       result = (bool)Dali::Equals(arg1,arg2);
14417     } catch (std::out_of_range& e) {
14418       {
14419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14420       };
14421     } catch (std::exception& e) {
14422       {
14423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14424       };
14425     } catch (Dali::DaliException e) {
14426       {
14427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14428       };
14429     } catch (...) {
14430       {
14431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14432       };
14433     }
14434   }
14435
14436   jresult = result;
14437   return jresult;
14438 }
14439
14440
14441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14442   unsigned int jresult ;
14443   float arg1 ;
14444   float arg2 ;
14445   float arg3 ;
14446   bool result;
14447
14448   arg1 = (float)jarg1;
14449   arg2 = (float)jarg2;
14450   arg3 = (float)jarg3;
14451   {
14452     try {
14453       result = (bool)Dali::Equals(arg1,arg2,arg3);
14454     } catch (std::out_of_range& e) {
14455       {
14456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14457       };
14458     } catch (std::exception& e) {
14459       {
14460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14461       };
14462     } catch (Dali::DaliException e) {
14463       {
14464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14465       };
14466     } catch (...) {
14467       {
14468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14469       };
14470     }
14471   }
14472
14473   jresult = result;
14474   return jresult;
14475 }
14476
14477
14478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14479   float jresult ;
14480   float arg1 ;
14481   int arg2 ;
14482   float result;
14483
14484   arg1 = (float)jarg1;
14485   arg2 = (int)jarg2;
14486   {
14487     try {
14488       result = (float)Dali::Round(arg1,arg2);
14489     } catch (std::out_of_range& e) {
14490       {
14491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14492       };
14493     } catch (std::exception& e) {
14494       {
14495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14496       };
14497     } catch (Dali::DaliException e) {
14498       {
14499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14500       };
14501     } catch (...) {
14502       {
14503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14504       };
14505     }
14506   }
14507
14508   jresult = result;
14509   return jresult;
14510 }
14511
14512
14513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14514   float jresult ;
14515   float arg1 ;
14516   float arg2 ;
14517   float arg3 ;
14518   float result;
14519
14520   arg1 = (float)jarg1;
14521   arg2 = (float)jarg2;
14522   arg3 = (float)jarg3;
14523   {
14524     try {
14525       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14526     } catch (std::out_of_range& e) {
14527       {
14528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14529       };
14530     } catch (std::exception& e) {
14531       {
14532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14533       };
14534     } catch (Dali::DaliException e) {
14535       {
14536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14537       };
14538     } catch (...) {
14539       {
14540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14541       };
14542     }
14543   }
14544
14545   jresult = result;
14546   return jresult;
14547 }
14548
14549
14550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14551   float jresult ;
14552   float arg1 ;
14553   float arg2 ;
14554   float arg3 ;
14555   float arg4 ;
14556   float result;
14557
14558   arg1 = (float)jarg1;
14559   arg2 = (float)jarg2;
14560   arg3 = (float)jarg3;
14561   arg4 = (float)jarg4;
14562   {
14563     try {
14564       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14565     } catch (std::out_of_range& e) {
14566       {
14567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14568       };
14569     } catch (std::exception& e) {
14570       {
14571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14572       };
14573     } catch (Dali::DaliException e) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14576       };
14577     } catch (...) {
14578       {
14579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14580       };
14581     }
14582   }
14583
14584   jresult = result;
14585   return jresult;
14586 }
14587
14588
14589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14590   int jresult ;
14591   int result;
14592
14593   result = (int)(int)Dali::Property::INVALID_INDEX;
14594   jresult = result;
14595   return jresult;
14596 }
14597
14598
14599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14600   int jresult ;
14601   int result;
14602
14603   result = (int)(int)Dali::Property::INVALID_KEY;
14604   jresult = result;
14605   return jresult;
14606 }
14607
14608
14609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14610   int jresult ;
14611   int result;
14612
14613   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14614   jresult = result;
14615   return jresult;
14616 }
14617
14618
14619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14620   void * jresult ;
14621   Dali::Handle *arg1 = 0 ;
14622   Dali::Property::Index arg2 ;
14623   Dali::Property *result = 0 ;
14624
14625   arg1 = (Dali::Handle *)jarg1;
14626   if (!arg1) {
14627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14628     return 0;
14629   }
14630   arg2 = (Dali::Property::Index)jarg2;
14631   {
14632     try {
14633       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14634     } catch (std::out_of_range& e) {
14635       {
14636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (std::exception& e) {
14639       {
14640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14641       };
14642     } catch (Dali::DaliException e) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14645       };
14646     } catch (...) {
14647       {
14648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14649       };
14650     }
14651   }
14652
14653   jresult = (void *)result;
14654   return jresult;
14655 }
14656
14657
14658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14659   void * jresult ;
14660   Dali::Handle *arg1 = 0 ;
14661   Dali::Property::Index arg2 ;
14662   int arg3 ;
14663   Dali::Property *result = 0 ;
14664
14665   arg1 = (Dali::Handle *)jarg1;
14666   if (!arg1) {
14667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14668     return 0;
14669   }
14670   arg2 = (Dali::Property::Index)jarg2;
14671   arg3 = (int)jarg3;
14672   {
14673     try {
14674       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14675     } catch (std::out_of_range& e) {
14676       {
14677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (std::exception& e) {
14680       {
14681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14682       };
14683     } catch (Dali::DaliException e) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14686       };
14687     } catch (...) {
14688       {
14689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14690       };
14691     }
14692   }
14693
14694   jresult = (void *)result;
14695   return jresult;
14696 }
14697
14698
14699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14700   void * jresult ;
14701   Dali::Handle *arg1 = 0 ;
14702   std::string *arg2 = 0 ;
14703   Dali::Property *result = 0 ;
14704
14705   arg1 = (Dali::Handle *)jarg1;
14706   if (!arg1) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14708     return 0;
14709   }
14710   if (!jarg2) {
14711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14712     return 0;
14713   }
14714   std::string arg2_str(jarg2);
14715   arg2 = &arg2_str;
14716   {
14717     try {
14718       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14719     } catch (std::out_of_range& e) {
14720       {
14721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (std::exception& e) {
14724       {
14725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (Dali::DaliException e) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14730       };
14731     } catch (...) {
14732       {
14733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14734       };
14735     }
14736   }
14737
14738   jresult = (void *)result;
14739
14740   //argout typemap for const std::string&
14741
14742   return jresult;
14743 }
14744
14745
14746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14747   void * jresult ;
14748   Dali::Handle *arg1 = 0 ;
14749   std::string *arg2 = 0 ;
14750   int arg3 ;
14751   Dali::Property *result = 0 ;
14752
14753   arg1 = (Dali::Handle *)jarg1;
14754   if (!arg1) {
14755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14756     return 0;
14757   }
14758   if (!jarg2) {
14759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14760     return 0;
14761   }
14762   std::string arg2_str(jarg2);
14763   arg2 = &arg2_str;
14764   arg3 = (int)jarg3;
14765   {
14766     try {
14767       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14768     } catch (std::out_of_range& e) {
14769       {
14770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (std::exception& e) {
14773       {
14774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (Dali::DaliException e) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14779       };
14780     } catch (...) {
14781       {
14782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14783       };
14784     }
14785   }
14786
14787   jresult = (void *)result;
14788
14789   //argout typemap for const std::string&
14790
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14796   Dali::Property *arg1 = (Dali::Property *) 0 ;
14797
14798   arg1 = (Dali::Property *)jarg1;
14799   {
14800     try {
14801       delete arg1;
14802     } catch (std::out_of_range& e) {
14803       {
14804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14805       };
14806     } catch (std::exception& e) {
14807       {
14808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14809       };
14810     } catch (Dali::DaliException e) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14813       };
14814     } catch (...) {
14815       {
14816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14817       };
14818     }
14819   }
14820
14821 }
14822
14823
14824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14825   Dali::Property *arg1 = (Dali::Property *) 0 ;
14826   Dali::Handle *arg2 = 0 ;
14827
14828   arg1 = (Dali::Property *)jarg1;
14829   arg2 = (Dali::Handle *)jarg2;
14830   if (!arg2) {
14831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14832     return ;
14833   }
14834   if (arg1) (arg1)->object = *arg2;
14835 }
14836
14837
14838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14839   void * jresult ;
14840   Dali::Property *arg1 = (Dali::Property *) 0 ;
14841   Dali::Handle *result = 0 ;
14842
14843   arg1 = (Dali::Property *)jarg1;
14844   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14845   jresult = (void *)result;
14846   return jresult;
14847 }
14848
14849
14850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14851   Dali::Property *arg1 = (Dali::Property *) 0 ;
14852   Dali::Property::Index arg2 ;
14853
14854   arg1 = (Dali::Property *)jarg1;
14855   arg2 = (Dali::Property::Index)jarg2;
14856   if (arg1) (arg1)->propertyIndex = arg2;
14857 }
14858
14859
14860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14861   int jresult ;
14862   Dali::Property *arg1 = (Dali::Property *) 0 ;
14863   Dali::Property::Index result;
14864
14865   arg1 = (Dali::Property *)jarg1;
14866   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14867   jresult = result;
14868   return jresult;
14869 }
14870
14871
14872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14873   Dali::Property *arg1 = (Dali::Property *) 0 ;
14874   int arg2 ;
14875
14876   arg1 = (Dali::Property *)jarg1;
14877   arg2 = (int)jarg2;
14878   if (arg1) (arg1)->componentIndex = arg2;
14879 }
14880
14881
14882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14883   int jresult ;
14884   Dali::Property *arg1 = (Dali::Property *) 0 ;
14885   int result;
14886
14887   arg1 = (Dali::Property *)jarg1;
14888   result = (int) ((arg1)->componentIndex);
14889   jresult = result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14895   void * jresult ;
14896   Dali::Property::Array *result = 0 ;
14897
14898   {
14899     try {
14900       result = (Dali::Property::Array *)new Dali::Property::Array();
14901     } catch (std::out_of_range& e) {
14902       {
14903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14904       };
14905     } catch (std::exception& e) {
14906       {
14907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14908       };
14909     } catch (Dali::DaliException e) {
14910       {
14911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14912       };
14913     } catch (...) {
14914       {
14915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14916       };
14917     }
14918   }
14919
14920   jresult = (void *)result;
14921   return jresult;
14922 }
14923
14924
14925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14926   void * jresult ;
14927   Dali::Property::Array *arg1 = 0 ;
14928   Dali::Property::Array *result = 0 ;
14929
14930   arg1 = (Dali::Property::Array *)jarg1;
14931   if (!arg1) {
14932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14933     return 0;
14934   }
14935   {
14936     try {
14937       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14938     } catch (std::out_of_range& e) {
14939       {
14940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (std::exception& e) {
14943       {
14944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14945       };
14946     } catch (Dali::DaliException e) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14949       };
14950     } catch (...) {
14951       {
14952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14953       };
14954     }
14955   }
14956
14957   jresult = (void *)result;
14958   return jresult;
14959 }
14960
14961
14962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14963   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14964
14965   arg1 = (Dali::Property::Array *)jarg1;
14966   {
14967     try {
14968       delete arg1;
14969     } catch (std::out_of_range& e) {
14970       {
14971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14972       };
14973     } catch (std::exception& e) {
14974       {
14975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14976       };
14977     } catch (Dali::DaliException e) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14980       };
14981     } catch (...) {
14982       {
14983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14984       };
14985     }
14986   }
14987
14988 }
14989
14990
14991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14992   unsigned long jresult ;
14993   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14994   Dali::Property::Array::SizeType result;
14995
14996   arg1 = (Dali::Property::Array *)jarg1;
14997   {
14998     try {
14999       result = ((Dali::Property::Array const *)arg1)->Size();
15000     } catch (std::out_of_range& e) {
15001       {
15002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (std::exception& e) {
15005       {
15006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (Dali::DaliException e) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15011       };
15012     } catch (...) {
15013       {
15014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15015       };
15016     }
15017   }
15018
15019   jresult = (unsigned long)result;
15020   return jresult;
15021 }
15022
15023
15024 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15025   unsigned long jresult ;
15026   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15027   Dali::Property::Array::SizeType result;
15028
15029   arg1 = (Dali::Property::Array *)jarg1;
15030   {
15031     try {
15032       result = ((Dali::Property::Array const *)arg1)->Count();
15033     } catch (std::out_of_range& e) {
15034       {
15035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (std::exception& e) {
15038       {
15039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15040       };
15041     } catch (Dali::DaliException e) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15044       };
15045     } catch (...) {
15046       {
15047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15048       };
15049     }
15050   }
15051
15052   jresult = (unsigned long)result;
15053   return jresult;
15054 }
15055
15056
15057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15058   unsigned int jresult ;
15059   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15060   bool result;
15061
15062   arg1 = (Dali::Property::Array *)jarg1;
15063   {
15064     try {
15065       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15066     } catch (std::out_of_range& e) {
15067       {
15068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (std::exception& e) {
15071       {
15072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15073       };
15074     } catch (Dali::DaliException e) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15077       };
15078     } catch (...) {
15079       {
15080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15081       };
15082     }
15083   }
15084
15085   jresult = result;
15086   return jresult;
15087 }
15088
15089
15090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15091   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15092
15093   arg1 = (Dali::Property::Array *)jarg1;
15094   {
15095     try {
15096       (arg1)->Clear();
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15104       };
15105     } catch (Dali::DaliException e) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15108       };
15109     } catch (...) {
15110       {
15111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15112       };
15113     }
15114   }
15115
15116 }
15117
15118
15119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15120   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15121   Dali::Property::Array::SizeType arg2 ;
15122
15123   arg1 = (Dali::Property::Array *)jarg1;
15124   arg2 = (Dali::Property::Array::SizeType)jarg2;
15125   {
15126     try {
15127       (arg1)->Reserve(arg2);
15128     } catch (std::out_of_range& e) {
15129       {
15130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (std::exception& e) {
15133       {
15134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15135       };
15136     } catch (Dali::DaliException e) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15143       };
15144     }
15145   }
15146
15147 }
15148
15149
15150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15151   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15152   Dali::Property::Array::SizeType arg2 ;
15153
15154   arg1 = (Dali::Property::Array *)jarg1;
15155   arg2 = (Dali::Property::Array::SizeType)jarg2;
15156   {
15157     try {
15158       (arg1)->Resize(arg2);
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15166       };
15167     } catch (Dali::DaliException e) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15174       };
15175     }
15176   }
15177
15178 }
15179
15180
15181 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15182   unsigned long jresult ;
15183   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15184   Dali::Property::Array::SizeType result;
15185
15186   arg1 = (Dali::Property::Array *)jarg1;
15187   {
15188     try {
15189       result = (arg1)->Capacity();
15190     } catch (std::out_of_range& e) {
15191       {
15192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15193       };
15194     } catch (std::exception& e) {
15195       {
15196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15197       };
15198     } catch (Dali::DaliException e) {
15199       {
15200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15201       };
15202     } catch (...) {
15203       {
15204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15205       };
15206     }
15207   }
15208
15209   jresult = (unsigned long)result;
15210   return jresult;
15211 }
15212
15213
15214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15215   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15216   Dali::Property::Value *arg2 = 0 ;
15217
15218   arg1 = (Dali::Property::Array *)jarg1;
15219   arg2 = (Dali::Property::Value *)jarg2;
15220   if (!arg2) {
15221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15222     return ;
15223   }
15224   {
15225     try {
15226       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15227     } catch (std::out_of_range& e) {
15228       {
15229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15230       };
15231     } catch (std::exception& e) {
15232       {
15233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15234       };
15235     } catch (Dali::DaliException e) {
15236       {
15237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15238       };
15239     } catch (...) {
15240       {
15241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15242       };
15243     }
15244   }
15245
15246 }
15247
15248
15249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15250   void * jresult ;
15251   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15252   Dali::Property::Value *arg2 = 0 ;
15253   Dali::Property::Array *result = 0 ;
15254
15255   arg1 = (Dali::Property::Array *)jarg1;
15256   arg2 = (Dali::Property::Value *)jarg2;
15257   if (!arg2) {
15258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15259     return 0;
15260   }
15261   {
15262     try {
15263       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15264     } catch (std::out_of_range& e) {
15265       {
15266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (std::exception& e) {
15269       {
15270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15271       };
15272     } catch (Dali::DaliException e) {
15273       {
15274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15275       };
15276     } catch (...) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15279       };
15280     }
15281   }
15282
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15289   void * jresult ;
15290   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15291   Dali::Property::Array::SizeType arg2 ;
15292   Dali::Property::Value *result = 0 ;
15293
15294   arg1 = (Dali::Property::Array *)jarg1;
15295   arg2 = (Dali::Property::Array::SizeType)jarg2;
15296   {
15297     try {
15298       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15299     } catch (std::out_of_range& e) {
15300       {
15301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (std::exception& e) {
15304       {
15305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (Dali::DaliException e) {
15308       {
15309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15310       };
15311     } catch (...) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15314       };
15315     }
15316   }
15317
15318   jresult = (void *)result;
15319   return jresult;
15320 }
15321
15322
15323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15324   void * jresult ;
15325   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15326   Dali::Property::Array::SizeType arg2 ;
15327   Dali::Property::Value *result = 0 ;
15328
15329   arg1 = (Dali::Property::Array *)jarg1;
15330   arg2 = (Dali::Property::Array::SizeType)jarg2;
15331   {
15332     try {
15333       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15334     } catch (std::out_of_range& e) {
15335       {
15336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15337       };
15338     } catch (std::exception& e) {
15339       {
15340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15341       };
15342     } catch (Dali::DaliException e) {
15343       {
15344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15345       };
15346     } catch (...) {
15347       {
15348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15349       };
15350     }
15351   }
15352
15353   jresult = (void *)result;
15354   return jresult;
15355 }
15356
15357
15358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15359   void * jresult ;
15360   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15361   Dali::Property::Array *arg2 = 0 ;
15362   Dali::Property::Array *result = 0 ;
15363
15364   arg1 = (Dali::Property::Array *)jarg1;
15365   arg2 = (Dali::Property::Array *)jarg2;
15366   if (!arg2) {
15367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15368     return 0;
15369   }
15370   {
15371     try {
15372       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15373     } catch (std::out_of_range& e) {
15374       {
15375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15376       };
15377     } catch (std::exception& e) {
15378       {
15379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15380       };
15381     } catch (Dali::DaliException e) {
15382       {
15383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15384       };
15385     } catch (...) {
15386       {
15387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15388       };
15389     }
15390   }
15391
15392   jresult = (void *)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15399   enum Dali::Property::Key::Type arg2 ;
15400
15401   arg1 = (Dali::Property::Key *)jarg1;
15402   arg2 = (enum Dali::Property::Key::Type)jarg2;
15403   if (arg1) (arg1)->type = arg2;
15404 }
15405
15406
15407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15408   int jresult ;
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   enum Dali::Property::Key::Type result;
15411
15412   arg1 = (Dali::Property::Key *)jarg1;
15413   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15414   jresult = (int)result;
15415   return jresult;
15416 }
15417
15418
15419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15420   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15421   Dali::Property::Index arg2 ;
15422
15423   arg1 = (Dali::Property::Key *)jarg1;
15424   arg2 = (Dali::Property::Index)jarg2;
15425   if (arg1) (arg1)->indexKey = arg2;
15426 }
15427
15428
15429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15430   int jresult ;
15431   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15432   Dali::Property::Index result;
15433
15434   arg1 = (Dali::Property::Key *)jarg1;
15435   result = (Dali::Property::Index) ((arg1)->indexKey);
15436   jresult = result;
15437   return jresult;
15438 }
15439
15440
15441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15442   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15443   std::string *arg2 = 0 ;
15444
15445   arg1 = (Dali::Property::Key *)jarg1;
15446   if (!jarg2) {
15447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15448     return ;
15449   }
15450   std::string arg2_str(jarg2);
15451   arg2 = &arg2_str;
15452   if (arg1) (arg1)->stringKey = *arg2;
15453
15454   //argout typemap for const std::string&
15455
15456 }
15457
15458
15459 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15460   char * jresult ;
15461   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15462   std::string *result = 0 ;
15463
15464   arg1 = (Dali::Property::Key *)jarg1;
15465   result = (std::string *) & ((arg1)->stringKey);
15466   jresult = SWIG_csharp_string_callback(result->c_str());
15467   return jresult;
15468 }
15469
15470
15471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15472   void * jresult ;
15473   std::string *arg1 = 0 ;
15474   Dali::Property::Key *result = 0 ;
15475
15476   if (!jarg1) {
15477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15478     return 0;
15479   }
15480   std::string arg1_str(jarg1);
15481   arg1 = &arg1_str;
15482   {
15483     try {
15484       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15485     } catch (std::out_of_range& e) {
15486       {
15487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15488       };
15489     } catch (std::exception& e) {
15490       {
15491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15492       };
15493     } catch (Dali::DaliException e) {
15494       {
15495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15496       };
15497     } catch (...) {
15498       {
15499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15500       };
15501     }
15502   }
15503
15504   jresult = (void *)result;
15505
15506   //argout typemap for const std::string&
15507
15508   return jresult;
15509 }
15510
15511
15512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15513   void * jresult ;
15514   Dali::Property::Index arg1 ;
15515   Dali::Property::Key *result = 0 ;
15516
15517   arg1 = (Dali::Property::Index)jarg1;
15518   {
15519     try {
15520       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15521     } catch (std::out_of_range& e) {
15522       {
15523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (std::exception& e) {
15526       {
15527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15528       };
15529     } catch (Dali::DaliException e) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15532       };
15533     } catch (...) {
15534       {
15535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15536       };
15537     }
15538   }
15539
15540   jresult = (void *)result;
15541   return jresult;
15542 }
15543
15544
15545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15546   unsigned int jresult ;
15547   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15548   std::string *arg2 = 0 ;
15549   bool result;
15550
15551   arg1 = (Dali::Property::Key *)jarg1;
15552   if (!jarg2) {
15553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15554     return 0;
15555   }
15556   std::string arg2_str(jarg2);
15557   arg2 = &arg2_str;
15558   {
15559     try {
15560       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15561     } catch (std::out_of_range& e) {
15562       {
15563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15564       };
15565     } catch (std::exception& e) {
15566       {
15567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15568       };
15569     } catch (Dali::DaliException e) {
15570       {
15571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15572       };
15573     } catch (...) {
15574       {
15575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15576       };
15577     }
15578   }
15579
15580   jresult = result;
15581
15582   //argout typemap for const std::string&
15583
15584   return jresult;
15585 }
15586
15587
15588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15589   unsigned int jresult ;
15590   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15591   Dali::Property::Index arg2 ;
15592   bool result;
15593
15594   arg1 = (Dali::Property::Key *)jarg1;
15595   arg2 = (Dali::Property::Index)jarg2;
15596   {
15597     try {
15598       result = (bool)(arg1)->operator ==(arg2);
15599     } catch (std::out_of_range& e) {
15600       {
15601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15602       };
15603     } catch (std::exception& e) {
15604       {
15605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15606       };
15607     } catch (Dali::DaliException e) {
15608       {
15609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15610       };
15611     } catch (...) {
15612       {
15613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15614       };
15615     }
15616   }
15617
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15626   Dali::Property::Key *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Key *)jarg1;
15630   arg2 = (Dali::Property::Key *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (Dali::DaliException e) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15649       };
15650     } catch (...) {
15651       {
15652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15653       };
15654     }
15655   }
15656
15657   jresult = result;
15658   return jresult;
15659 }
15660
15661
15662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15663   unsigned int jresult ;
15664   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15665   std::string *arg2 = 0 ;
15666   bool result;
15667
15668   arg1 = (Dali::Property::Key *)jarg1;
15669   if (!jarg2) {
15670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15671     return 0;
15672   }
15673   std::string arg2_str(jarg2);
15674   arg2 = &arg2_str;
15675   {
15676     try {
15677       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15678     } catch (std::out_of_range& e) {
15679       {
15680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (std::exception& e) {
15683       {
15684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15685       };
15686     } catch (Dali::DaliException e) {
15687       {
15688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15689       };
15690     } catch (...) {
15691       {
15692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15693       };
15694     }
15695   }
15696
15697   jresult = result;
15698
15699   //argout typemap for const std::string&
15700
15701   return jresult;
15702 }
15703
15704
15705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15706   unsigned int jresult ;
15707   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15708   Dali::Property::Index arg2 ;
15709   bool result;
15710
15711   arg1 = (Dali::Property::Key *)jarg1;
15712   arg2 = (Dali::Property::Index)jarg2;
15713   {
15714     try {
15715       result = (bool)(arg1)->operator !=(arg2);
15716     } catch (std::out_of_range& e) {
15717       {
15718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (std::exception& e) {
15721       {
15722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15723       };
15724     } catch (Dali::DaliException e) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15727       };
15728     } catch (...) {
15729       {
15730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15731       };
15732     }
15733   }
15734
15735   jresult = result;
15736   return jresult;
15737 }
15738
15739
15740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15741   unsigned int jresult ;
15742   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15743   Dali::Property::Key *arg2 = 0 ;
15744   bool result;
15745
15746   arg1 = (Dali::Property::Key *)jarg1;
15747   arg2 = (Dali::Property::Key *)jarg2;
15748   if (!arg2) {
15749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15750     return 0;
15751   }
15752   {
15753     try {
15754       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15755     } catch (std::out_of_range& e) {
15756       {
15757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (std::exception& e) {
15760       {
15761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15762       };
15763     } catch (Dali::DaliException e) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15766       };
15767     } catch (...) {
15768       {
15769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15770       };
15771     }
15772   }
15773
15774   jresult = result;
15775   return jresult;
15776 }
15777
15778
15779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15780   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15781
15782   arg1 = (Dali::Property::Key *)jarg1;
15783   {
15784     try {
15785       delete arg1;
15786     } catch (std::out_of_range& e) {
15787       {
15788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15789       };
15790     } catch (std::exception& e) {
15791       {
15792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15793       };
15794     } catch (Dali::DaliException e) {
15795       {
15796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15797       };
15798     } catch (...) {
15799       {
15800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15801       };
15802     }
15803   }
15804
15805 }
15806
15807
15808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15809   void * jresult ;
15810   Dali::Property::Map *result = 0 ;
15811
15812   {
15813     try {
15814       result = (Dali::Property::Map *)new Dali::Property::Map();
15815     } catch (std::out_of_range& e) {
15816       {
15817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (std::exception& e) {
15820       {
15821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15822       };
15823     } catch (Dali::DaliException e) {
15824       {
15825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15826       };
15827     } catch (...) {
15828       {
15829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15830       };
15831     }
15832   }
15833
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15840   void * jresult ;
15841   Dali::Property::Map *arg1 = 0 ;
15842   Dali::Property::Map *result = 0 ;
15843
15844   arg1 = (Dali::Property::Map *)jarg1;
15845   if (!arg1) {
15846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15847     return 0;
15848   }
15849   {
15850     try {
15851       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15859       };
15860     } catch (Dali::DaliException e) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15863       };
15864     } catch (...) {
15865       {
15866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15867       };
15868     }
15869   }
15870
15871   jresult = (void *)result;
15872   return jresult;
15873 }
15874
15875
15876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15877   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15878
15879   arg1 = (Dali::Property::Map *)jarg1;
15880   {
15881     try {
15882       delete arg1;
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15890       };
15891     } catch (Dali::DaliException e) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15894       };
15895     } catch (...) {
15896       {
15897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15898       };
15899     }
15900   }
15901
15902 }
15903
15904
15905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15906   unsigned long jresult ;
15907   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15908   Dali::Property::Map::SizeType result;
15909
15910   arg1 = (Dali::Property::Map *)jarg1;
15911   {
15912     try {
15913       result = ((Dali::Property::Map const *)arg1)->Count();
15914     } catch (std::out_of_range& e) {
15915       {
15916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15917       };
15918     } catch (std::exception& e) {
15919       {
15920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15921       };
15922     } catch (Dali::DaliException e) {
15923       {
15924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15925       };
15926     } catch (...) {
15927       {
15928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15929       };
15930     }
15931   }
15932
15933   jresult = (unsigned long)result;
15934   return jresult;
15935 }
15936
15937
15938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15939   unsigned int jresult ;
15940   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15941   bool result;
15942
15943   arg1 = (Dali::Property::Map *)jarg1;
15944   {
15945     try {
15946       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15947     } catch (std::out_of_range& e) {
15948       {
15949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15950       };
15951     } catch (std::exception& e) {
15952       {
15953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15954       };
15955     } catch (Dali::DaliException e) {
15956       {
15957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15958       };
15959     } catch (...) {
15960       {
15961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15962       };
15963     }
15964   }
15965
15966   jresult = result;
15967   return jresult;
15968 }
15969
15970
15971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15972   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15973   char *arg2 = (char *) 0 ;
15974   Dali::Property::Value *arg3 = 0 ;
15975
15976   arg1 = (Dali::Property::Map *)jarg1;
15977   arg2 = (char *)jarg2;
15978   arg3 = (Dali::Property::Value *)jarg3;
15979   if (!arg3) {
15980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15981     return ;
15982   }
15983   {
15984     try {
15985       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15986     } catch (std::out_of_range& e) {
15987       {
15988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15989       };
15990     } catch (std::exception& e) {
15991       {
15992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15993       };
15994     } catch (Dali::DaliException e) {
15995       {
15996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15997       };
15998     } catch (...) {
15999       {
16000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16001       };
16002     }
16003   }
16004
16005 }
16006
16007
16008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16009   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16010   Dali::Property::Index arg2 ;
16011   Dali::Property::Value *arg3 = 0 ;
16012
16013   arg1 = (Dali::Property::Map *)jarg1;
16014   arg2 = (Dali::Property::Index)jarg2;
16015   arg3 = (Dali::Property::Value *)jarg3;
16016   if (!arg3) {
16017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16018     return ;
16019   }
16020   {
16021     try {
16022       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16023     } catch (std::out_of_range& e) {
16024       {
16025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16026       };
16027     } catch (std::exception& e) {
16028       {
16029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16030       };
16031     } catch (Dali::DaliException e) {
16032       {
16033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16034       };
16035     } catch (...) {
16036       {
16037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16038       };
16039     }
16040   }
16041
16042 }
16043
16044
16045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16046   void * jresult ;
16047   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16048   char *arg2 = (char *) 0 ;
16049   Dali::Property::Value *arg3 = 0 ;
16050   Dali::Property::Map *result = 0 ;
16051
16052   arg1 = (Dali::Property::Map *)jarg1;
16053   arg2 = (char *)jarg2;
16054   arg3 = (Dali::Property::Value *)jarg3;
16055   if (!arg3) {
16056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16057     return 0;
16058   }
16059   {
16060     try {
16061       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16062     } catch (std::out_of_range& e) {
16063       {
16064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (std::exception& e) {
16067       {
16068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16069       };
16070     } catch (Dali::DaliException e) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16073       };
16074     } catch (...) {
16075       {
16076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16077       };
16078     }
16079   }
16080
16081   jresult = (void *)result;
16082   return jresult;
16083 }
16084
16085
16086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16087   void * jresult ;
16088   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16089   Dali::Property::Index arg2 ;
16090   Dali::Property::Value *arg3 = 0 ;
16091   Dali::Property::Map *result = 0 ;
16092
16093   arg1 = (Dali::Property::Map *)jarg1;
16094   arg2 = (Dali::Property::Index)jarg2;
16095   arg3 = (Dali::Property::Value *)jarg3;
16096   if (!arg3) {
16097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16098     return 0;
16099   }
16100   {
16101     try {
16102       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16103     } catch (std::out_of_range& e) {
16104       {
16105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16106       };
16107     } catch (std::exception& e) {
16108       {
16109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (Dali::DaliException e) {
16112       {
16113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16114       };
16115     } catch (...) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16118       };
16119     }
16120   }
16121
16122   jresult = (void *)result;
16123   return jresult;
16124 }
16125
16126
16127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16128   void * jresult ;
16129   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16130   Dali::Property::Map::SizeType arg2 ;
16131   Dali::Property::Value *result = 0 ;
16132
16133   arg1 = (Dali::Property::Map *)jarg1;
16134   arg2 = (Dali::Property::Map::SizeType)jarg2;
16135   {
16136     try {
16137       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (Dali::DaliException e) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16149       };
16150     } catch (...) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16153       };
16154     }
16155   }
16156
16157   jresult = (void *)result;
16158   return jresult;
16159 }
16160
16161
16162 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16163   char * jresult ;
16164   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16165   Dali::Property::Map::SizeType arg2 ;
16166   std::string *result = 0 ;
16167
16168   arg1 = (Dali::Property::Map *)jarg1;
16169   arg2 = (Dali::Property::Map::SizeType)jarg2;
16170   {
16171     try {
16172       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16173     } catch (std::out_of_range& e) {
16174       {
16175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (std::exception& e) {
16178       {
16179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (Dali::DaliException e) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16184       };
16185     } catch (...) {
16186       {
16187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16188       };
16189     }
16190   }
16191
16192   jresult = SWIG_csharp_string_callback(result->c_str());
16193   return jresult;
16194 }
16195
16196
16197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16198   void * jresult ;
16199   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16200   Dali::Property::Map::SizeType arg2 ;
16201   SwigValueWrapper< Dali::Property::Key > result;
16202
16203   arg1 = (Dali::Property::Map *)jarg1;
16204   arg2 = (Dali::Property::Map::SizeType)jarg2;
16205   {
16206     try {
16207       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16208     } catch (std::out_of_range& e) {
16209       {
16210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16211       };
16212     } catch (std::exception& e) {
16213       {
16214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (Dali::DaliException e) {
16217       {
16218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16219       };
16220     } catch (...) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16223       };
16224     }
16225   }
16226
16227   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16228   return jresult;
16229 }
16230
16231
16232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16233   void * jresult ;
16234   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16235   Dali::Property::Map::SizeType arg2 ;
16236   StringValuePair *result = 0 ;
16237
16238   arg1 = (Dali::Property::Map *)jarg1;
16239   arg2 = (Dali::Property::Map::SizeType)jarg2;
16240   {
16241     try {
16242       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16243     } catch (std::out_of_range& e) {
16244       {
16245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16246       };
16247     } catch (std::exception& e) {
16248       {
16249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16250       };
16251     } catch (Dali::DaliException e) {
16252       {
16253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16254       };
16255     } catch (...) {
16256       {
16257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16258       };
16259     }
16260   }
16261
16262   jresult = (void *)result;
16263   return jresult;
16264 }
16265
16266
16267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16268   void * jresult ;
16269   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16270   char *arg2 = (char *) 0 ;
16271   Dali::Property::Value *result = 0 ;
16272
16273   arg1 = (Dali::Property::Map *)jarg1;
16274   arg2 = (char *)jarg2;
16275   {
16276     try {
16277       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16278     } catch (std::out_of_range& e) {
16279       {
16280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (std::exception& e) {
16283       {
16284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (Dali::DaliException e) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16289       };
16290     } catch (...) {
16291       {
16292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16293       };
16294     }
16295   }
16296
16297   jresult = (void *)result;
16298   return jresult;
16299 }
16300
16301
16302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16303   void * jresult ;
16304   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16305   Dali::Property::Index arg2 ;
16306   Dali::Property::Value *result = 0 ;
16307
16308   arg1 = (Dali::Property::Map *)jarg1;
16309   arg2 = (Dali::Property::Index)jarg2;
16310   {
16311     try {
16312       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16313     } catch (std::out_of_range& e) {
16314       {
16315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16316       };
16317     } catch (std::exception& e) {
16318       {
16319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16320       };
16321     } catch (Dali::DaliException e) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16324       };
16325     } catch (...) {
16326       {
16327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16328       };
16329     }
16330   }
16331
16332   jresult = (void *)result;
16333   return jresult;
16334 }
16335
16336
16337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16338   void * jresult ;
16339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16340   Dali::Property::Index arg2 ;
16341   std::string *arg3 = 0 ;
16342   Dali::Property::Value *result = 0 ;
16343
16344   arg1 = (Dali::Property::Map *)jarg1;
16345   arg2 = (Dali::Property::Index)jarg2;
16346   if (!jarg3) {
16347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16348     return 0;
16349   }
16350   std::string arg3_str(jarg3);
16351   arg3 = &arg3_str;
16352   {
16353     try {
16354       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16355     } catch (std::out_of_range& e) {
16356       {
16357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (std::exception& e) {
16360       {
16361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (Dali::DaliException e) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373
16374   jresult = (void *)result;
16375
16376   //argout typemap for const std::string&
16377
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16383   void * jresult ;
16384   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16385   std::string *arg2 = 0 ;
16386   Dali::Property::Type arg3 ;
16387   Dali::Property::Value *result = 0 ;
16388
16389   arg1 = (Dali::Property::Map *)jarg1;
16390   if (!jarg2) {
16391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16392     return 0;
16393   }
16394   std::string arg2_str(jarg2);
16395   arg2 = &arg2_str;
16396   arg3 = (Dali::Property::Type)jarg3;
16397   {
16398     try {
16399       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16400     } catch (std::out_of_range& e) {
16401       {
16402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16403       };
16404     } catch (std::exception& e) {
16405       {
16406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16407       };
16408     } catch (Dali::DaliException e) {
16409       {
16410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16411       };
16412     } catch (...) {
16413       {
16414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16415       };
16416     }
16417   }
16418
16419   jresult = (void *)result;
16420
16421   //argout typemap for const std::string&
16422
16423   return jresult;
16424 }
16425
16426
16427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16428   void * jresult ;
16429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16430   Dali::Property::Index arg2 ;
16431   Dali::Property::Type arg3 ;
16432   Dali::Property::Value *result = 0 ;
16433
16434   arg1 = (Dali::Property::Map *)jarg1;
16435   arg2 = (Dali::Property::Index)jarg2;
16436   arg3 = (Dali::Property::Type)jarg3;
16437   {
16438     try {
16439       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16440     } catch (std::out_of_range& e) {
16441       {
16442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (std::exception& e) {
16445       {
16446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16447       };
16448     } catch (Dali::DaliException e) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16451       };
16452     } catch (...) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16455       };
16456     }
16457   }
16458
16459   jresult = (void *)result;
16460   return jresult;
16461 }
16462
16463
16464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16465   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16466
16467   arg1 = (Dali::Property::Map *)jarg1;
16468   {
16469     try {
16470       (arg1)->Clear();
16471     } catch (std::out_of_range& e) {
16472       {
16473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16474       };
16475     } catch (std::exception& e) {
16476       {
16477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16478       };
16479     } catch (Dali::DaliException e) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16482       };
16483     } catch (...) {
16484       {
16485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16486       };
16487     }
16488   }
16489
16490 }
16491
16492
16493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16494   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16495   Dali::Property::Map *arg2 = 0 ;
16496
16497   arg1 = (Dali::Property::Map *)jarg1;
16498   arg2 = (Dali::Property::Map *)jarg2;
16499   if (!arg2) {
16500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16501     return ;
16502   }
16503   {
16504     try {
16505       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16506     } catch (std::out_of_range& e) {
16507       {
16508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16509       };
16510     } catch (std::exception& e) {
16511       {
16512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16513       };
16514     } catch (Dali::DaliException e) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16517       };
16518     } catch (...) {
16519       {
16520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16521       };
16522     }
16523   }
16524
16525 }
16526
16527
16528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16529   void * jresult ;
16530   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16531   std::string *arg2 = 0 ;
16532   Dali::Property::Value *result = 0 ;
16533
16534   arg1 = (Dali::Property::Map *)jarg1;
16535   if (!jarg2) {
16536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16537     return 0;
16538   }
16539   std::string arg2_str(jarg2);
16540   arg2 = &arg2_str;
16541   {
16542     try {
16543       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16544     } catch (std::out_of_range& e) {
16545       {
16546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16547       };
16548     } catch (std::exception& e) {
16549       {
16550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16551       };
16552     } catch (Dali::DaliException e) {
16553       {
16554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16559       };
16560     }
16561   }
16562
16563   jresult = (void *)result;
16564
16565   //argout typemap for const std::string&
16566
16567   return jresult;
16568 }
16569
16570
16571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16572   void * jresult ;
16573   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16574   Dali::Property::Index arg2 ;
16575   Dali::Property::Value *result = 0 ;
16576
16577   arg1 = (Dali::Property::Map *)jarg1;
16578   arg2 = (Dali::Property::Index)jarg2;
16579   {
16580     try {
16581       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16582     } catch (std::out_of_range& e) {
16583       {
16584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16585       };
16586     } catch (std::exception& e) {
16587       {
16588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16589       };
16590     } catch (Dali::DaliException e) {
16591       {
16592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16597       };
16598     }
16599   }
16600
16601   jresult = (void *)result;
16602   return jresult;
16603 }
16604
16605
16606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16607   void * jresult ;
16608   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16609   Dali::Property::Map *arg2 = 0 ;
16610   Dali::Property::Map *result = 0 ;
16611
16612   arg1 = (Dali::Property::Map *)jarg1;
16613   arg2 = (Dali::Property::Map *)jarg2;
16614   if (!arg2) {
16615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16616     return 0;
16617   }
16618   {
16619     try {
16620       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16621     } catch (std::out_of_range& e) {
16622       {
16623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16624       };
16625     } catch (std::exception& e) {
16626       {
16627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16628       };
16629     } catch (Dali::DaliException e) {
16630       {
16631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16632       };
16633     } catch (...) {
16634       {
16635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16636       };
16637     }
16638   }
16639
16640   jresult = (void *)result;
16641   return jresult;
16642 }
16643
16644
16645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16646   void * jresult ;
16647   Dali::Property::Value *result = 0 ;
16648
16649   {
16650     try {
16651       result = (Dali::Property::Value *)new Dali::Property::Value();
16652     } catch (std::out_of_range& e) {
16653       {
16654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16655       };
16656     } catch (std::exception& e) {
16657       {
16658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16659       };
16660     } catch (Dali::DaliException e) {
16661       {
16662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16663       };
16664     } catch (...) {
16665       {
16666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16667       };
16668     }
16669   }
16670
16671   jresult = (void *)result;
16672   return jresult;
16673 }
16674
16675
16676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16677   void * jresult ;
16678   bool arg1 ;
16679   Dali::Property::Value *result = 0 ;
16680
16681   arg1 = jarg1 ? true : false;
16682   {
16683     try {
16684       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16685     } catch (std::out_of_range& e) {
16686       {
16687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16688       };
16689     } catch (std::exception& e) {
16690       {
16691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16692       };
16693     } catch (Dali::DaliException e) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16696       };
16697     } catch (...) {
16698       {
16699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16700       };
16701     }
16702   }
16703
16704   jresult = (void *)result;
16705   return jresult;
16706 }
16707
16708
16709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16710   void * jresult ;
16711   int arg1 ;
16712   Dali::Property::Value *result = 0 ;
16713
16714   arg1 = (int)jarg1;
16715   {
16716     try {
16717       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16718     } catch (std::out_of_range& e) {
16719       {
16720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16721       };
16722     } catch (std::exception& e) {
16723       {
16724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16725       };
16726     } catch (Dali::DaliException e) {
16727       {
16728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16729       };
16730     } catch (...) {
16731       {
16732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16733       };
16734     }
16735   }
16736
16737   jresult = (void *)result;
16738   return jresult;
16739 }
16740
16741
16742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16743   void * jresult ;
16744   float arg1 ;
16745   Dali::Property::Value *result = 0 ;
16746
16747   arg1 = (float)jarg1;
16748   {
16749     try {
16750       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16751     } catch (std::out_of_range& e) {
16752       {
16753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16754       };
16755     } catch (std::exception& e) {
16756       {
16757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16758       };
16759     } catch (Dali::DaliException e) {
16760       {
16761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16762       };
16763     } catch (...) {
16764       {
16765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16766       };
16767     }
16768   }
16769
16770   jresult = (void *)result;
16771   return jresult;
16772 }
16773
16774
16775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16776   void * jresult ;
16777   Dali::Vector2 *arg1 = 0 ;
16778   Dali::Property::Value *result = 0 ;
16779
16780   arg1 = (Dali::Vector2 *)jarg1;
16781   if (!arg1) {
16782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16783     return 0;
16784   }
16785   {
16786     try {
16787       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16788     } catch (std::out_of_range& e) {
16789       {
16790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16791       };
16792     } catch (std::exception& e) {
16793       {
16794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16795       };
16796     } catch (Dali::DaliException e) {
16797       {
16798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16799       };
16800     } catch (...) {
16801       {
16802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16803       };
16804     }
16805   }
16806
16807   jresult = (void *)result;
16808   return jresult;
16809 }
16810
16811
16812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16813   void * jresult ;
16814   Dali::Vector3 *arg1 = 0 ;
16815   Dali::Property::Value *result = 0 ;
16816
16817   arg1 = (Dali::Vector3 *)jarg1;
16818   if (!arg1) {
16819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16820     return 0;
16821   }
16822   {
16823     try {
16824       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16825     } catch (std::out_of_range& e) {
16826       {
16827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (std::exception& e) {
16830       {
16831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16832       };
16833     } catch (Dali::DaliException e) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16836       };
16837     } catch (...) {
16838       {
16839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16840       };
16841     }
16842   }
16843
16844   jresult = (void *)result;
16845   return jresult;
16846 }
16847
16848
16849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16850   void * jresult ;
16851   Dali::Vector4 *arg1 = 0 ;
16852   Dali::Property::Value *result = 0 ;
16853
16854   arg1 = (Dali::Vector4 *)jarg1;
16855   if (!arg1) {
16856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16857     return 0;
16858   }
16859   {
16860     try {
16861       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16862     } catch (std::out_of_range& e) {
16863       {
16864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (std::exception& e) {
16867       {
16868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (Dali::DaliException e) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16877       };
16878     }
16879   }
16880
16881   jresult = (void *)result;
16882   return jresult;
16883 }
16884
16885
16886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16887   void * jresult ;
16888   Dali::Matrix3 *arg1 = 0 ;
16889   Dali::Property::Value *result = 0 ;
16890
16891   arg1 = (Dali::Matrix3 *)jarg1;
16892   if (!arg1) {
16893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16894     return 0;
16895   }
16896   {
16897     try {
16898       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16899     } catch (std::out_of_range& e) {
16900       {
16901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (std::exception& e) {
16904       {
16905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16906       };
16907     } catch (Dali::DaliException e) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16910       };
16911     } catch (...) {
16912       {
16913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16914       };
16915     }
16916   }
16917
16918   jresult = (void *)result;
16919   return jresult;
16920 }
16921
16922
16923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16924   void * jresult ;
16925   Dali::Matrix *arg1 = 0 ;
16926   Dali::Property::Value *result = 0 ;
16927
16928   arg1 = (Dali::Matrix *)jarg1;
16929   if (!arg1) {
16930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16931     return 0;
16932   }
16933   {
16934     try {
16935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16936     } catch (std::out_of_range& e) {
16937       {
16938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (std::exception& e) {
16941       {
16942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16943       };
16944     } catch (Dali::DaliException e) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16947       };
16948     } catch (...) {
16949       {
16950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16951       };
16952     }
16953   }
16954
16955   jresult = (void *)result;
16956   return jresult;
16957 }
16958
16959
16960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16961   void * jresult ;
16962   Dali::Rect< int > *arg1 = 0 ;
16963   Dali::Property::Value *result = 0 ;
16964
16965   arg1 = (Dali::Rect< int > *)jarg1;
16966   if (!arg1) {
16967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16968     return 0;
16969   }
16970   {
16971     try {
16972       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16973     } catch (std::out_of_range& e) {
16974       {
16975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (std::exception& e) {
16978       {
16979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (Dali::DaliException e) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991
16992   jresult = (void *)result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16998   void * jresult ;
16999   Dali::AngleAxis *arg1 = 0 ;
17000   Dali::Property::Value *result = 0 ;
17001
17002   arg1 = (Dali::AngleAxis *)jarg1;
17003   if (!arg1) {
17004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17005     return 0;
17006   }
17007   {
17008     try {
17009       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (Dali::DaliException e) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17021       };
17022     } catch (...) {
17023       {
17024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17025       };
17026     }
17027   }
17028
17029   jresult = (void *)result;
17030   return jresult;
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17035   void * jresult ;
17036   Dali::Quaternion *arg1 = 0 ;
17037   Dali::Property::Value *result = 0 ;
17038
17039   arg1 = (Dali::Quaternion *)jarg1;
17040   if (!arg1) {
17041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17042     return 0;
17043   }
17044   {
17045     try {
17046       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (Dali::DaliException e) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17058       };
17059     } catch (...) {
17060       {
17061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17062       };
17063     }
17064   }
17065
17066   jresult = (void *)result;
17067   return jresult;
17068 }
17069
17070
17071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17072   void * jresult ;
17073   std::string *arg1 = 0 ;
17074   Dali::Property::Value *result = 0 ;
17075
17076   if (!jarg1) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17078     return 0;
17079   }
17080   std::string arg1_str(jarg1);
17081   arg1 = &arg1_str;
17082   {
17083     try {
17084       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17085     } catch (std::out_of_range& e) {
17086       {
17087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (std::exception& e) {
17090       {
17091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17092       };
17093     } catch (Dali::DaliException e) {
17094       {
17095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17096       };
17097     } catch (...) {
17098       {
17099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17100       };
17101     }
17102   }
17103
17104   jresult = (void *)result;
17105
17106   //argout typemap for const std::string&
17107
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17113   void * jresult ;
17114   Dali::Property::Array *arg1 = 0 ;
17115   Dali::Property::Value *result = 0 ;
17116
17117   arg1 = (Dali::Property::Array *)jarg1;
17118   if (!arg1) {
17119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17120     return 0;
17121   }
17122   {
17123     try {
17124       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17125     } catch (std::out_of_range& e) {
17126       {
17127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (std::exception& e) {
17130       {
17131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (Dali::DaliException e) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17136       };
17137     } catch (...) {
17138       {
17139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17140       };
17141     }
17142   }
17143
17144   jresult = (void *)result;
17145   return jresult;
17146 }
17147
17148
17149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17150   void * jresult ;
17151   Dali::Property::Map *arg1 = 0 ;
17152   Dali::Property::Value *result = 0 ;
17153
17154   arg1 = (Dali::Property::Map *)jarg1;
17155   if (!arg1) {
17156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17157     return 0;
17158   }
17159   {
17160     try {
17161       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17162     } catch (std::out_of_range& e) {
17163       {
17164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (std::exception& e) {
17167       {
17168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17169       };
17170     } catch (Dali::DaliException e) {
17171       {
17172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17173       };
17174     } catch (...) {
17175       {
17176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17177       };
17178     }
17179   }
17180
17181   jresult = (void *)result;
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17187   void * jresult ;
17188   Extents *arg1 = 0 ;
17189   Dali::Property::Value *result = 0 ;
17190
17191   arg1 = (Extents *)jarg1;
17192   if (!arg1) {
17193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17194     return 0;
17195   }
17196   {
17197     try {
17198       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17199     } catch (std::out_of_range& e) {
17200       {
17201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (std::exception& e) {
17204       {
17205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17206       };
17207     } catch (...) {
17208       {
17209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17210       };
17211     }
17212   }
17213   jresult = (void *)result;
17214   return jresult;
17215 }
17216
17217
17218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17219   void * jresult ;
17220   Dali::Property::Type arg1 ;
17221   Dali::Property::Value *result = 0 ;
17222
17223   arg1 = (Dali::Property::Type)jarg1;
17224   {
17225     try {
17226       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17227     } catch (std::out_of_range& e) {
17228       {
17229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (std::exception& e) {
17232       {
17233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (Dali::DaliException e) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17238       };
17239     } catch (...) {
17240       {
17241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17242       };
17243     }
17244   }
17245
17246   jresult = (void *)result;
17247   return jresult;
17248 }
17249
17250
17251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17252   void * jresult ;
17253   Dali::Property::Value *arg1 = 0 ;
17254   Dali::Property::Value *result = 0 ;
17255
17256   arg1 = (Dali::Property::Value *)jarg1;
17257   if (!arg1) {
17258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17259     return 0;
17260   }
17261   {
17262     try {
17263       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17264     } catch (std::out_of_range& e) {
17265       {
17266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17267       };
17268     } catch (std::exception& e) {
17269       {
17270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17271       };
17272     } catch (Dali::DaliException e) {
17273       {
17274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17275       };
17276     } catch (...) {
17277       {
17278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17279       };
17280     }
17281   }
17282
17283   jresult = (void *)result;
17284   return jresult;
17285 }
17286
17287
17288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17289   void * jresult ;
17290   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17291   Dali::Property::Value *arg2 = 0 ;
17292   Dali::Property::Value *result = 0 ;
17293
17294   arg1 = (Dali::Property::Value *)jarg1;
17295   arg2 = (Dali::Property::Value *)jarg2;
17296   if (!arg2) {
17297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17298     return 0;
17299   }
17300   {
17301     try {
17302       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17303     } catch (std::out_of_range& e) {
17304       {
17305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (std::exception& e) {
17308       {
17309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (Dali::DaliException e) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17314       };
17315     } catch (...) {
17316       {
17317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17318       };
17319     }
17320   }
17321
17322   jresult = (void *)result;
17323   return jresult;
17324 }
17325
17326
17327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17328   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   {
17332     try {
17333       delete arg1;
17334     } catch (std::out_of_range& e) {
17335       {
17336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17337       };
17338     } catch (std::exception& e) {
17339       {
17340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17341       };
17342     } catch (Dali::DaliException e) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17345       };
17346     } catch (...) {
17347       {
17348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17349       };
17350     }
17351   }
17352
17353 }
17354
17355
17356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17357   int jresult ;
17358   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17359   Dali::Property::Type result;
17360
17361   arg1 = (Dali::Property::Value *)jarg1;
17362   {
17363     try {
17364       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17365     } catch (std::out_of_range& e) {
17366       {
17367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17368       };
17369     } catch (std::exception& e) {
17370       {
17371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17372       };
17373     } catch (Dali::DaliException e) {
17374       {
17375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17376       };
17377     } catch (...) {
17378       {
17379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17380       };
17381     }
17382   }
17383
17384   jresult = (int)result;
17385   return jresult;
17386 }
17387
17388
17389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17390   unsigned int jresult ;
17391   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17392   bool *arg2 = 0 ;
17393   bool result;
17394
17395   arg1 = (Dali::Property::Value *)jarg1;
17396   arg2 = (bool *)jarg2;
17397   {
17398     try {
17399       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17400     } catch (std::out_of_range& e) {
17401       {
17402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17403       };
17404     } catch (std::exception& e) {
17405       {
17406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17407       };
17408     } catch (Dali::DaliException e) {
17409       {
17410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17411       };
17412     } catch (...) {
17413       {
17414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17415       };
17416     }
17417   }
17418
17419   jresult = result;
17420   return jresult;
17421 }
17422
17423
17424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17425   unsigned int jresult ;
17426   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17427   float *arg2 = 0 ;
17428   bool result;
17429
17430   arg1 = (Dali::Property::Value *)jarg1;
17431   arg2 = (float *)jarg2;
17432   {
17433     try {
17434       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17435     } catch (std::out_of_range& e) {
17436       {
17437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17438       };
17439     } catch (std::exception& e) {
17440       {
17441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17442       };
17443     } catch (Dali::DaliException e) {
17444       {
17445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17446       };
17447     } catch (...) {
17448       {
17449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17450       };
17451     }
17452   }
17453
17454   jresult = result;
17455   return jresult;
17456 }
17457
17458
17459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17460   unsigned int jresult ;
17461   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17462   int *arg2 = 0 ;
17463   bool result;
17464
17465   arg1 = (Dali::Property::Value *)jarg1;
17466   arg2 = (int *)jarg2;
17467   {
17468     try {
17469       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17470     } catch (std::out_of_range& e) {
17471       {
17472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17473       };
17474     } catch (std::exception& e) {
17475       {
17476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17477       };
17478     } catch (Dali::DaliException e) {
17479       {
17480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17481       };
17482     } catch (...) {
17483       {
17484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17485       };
17486     }
17487   }
17488
17489   jresult = result;
17490   return jresult;
17491 }
17492
17493
17494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17495   unsigned int jresult ;
17496   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17497   Dali::Rect< int > *arg2 = 0 ;
17498   bool result;
17499
17500   arg1 = (Dali::Property::Value *)jarg1;
17501   arg2 = (Dali::Rect< int > *)jarg2;
17502   if (!arg2) {
17503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17504     return 0;
17505   }
17506   {
17507     try {
17508       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17509     } catch (std::out_of_range& e) {
17510       {
17511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (std::exception& e) {
17514       {
17515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17516       };
17517     } catch (Dali::DaliException e) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17524       };
17525     }
17526   }
17527
17528   jresult = result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17534   unsigned int jresult ;
17535   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17536   Dali::Vector2 *arg2 = 0 ;
17537   bool result;
17538
17539   arg1 = (Dali::Property::Value *)jarg1;
17540   arg2 = (Dali::Vector2 *)jarg2;
17541   if (!arg2) {
17542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17543     return 0;
17544   }
17545   {
17546     try {
17547       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17548     } catch (std::out_of_range& e) {
17549       {
17550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (std::exception& e) {
17553       {
17554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17555       };
17556     } catch (Dali::DaliException e) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17559       };
17560     } catch (...) {
17561       {
17562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17563       };
17564     }
17565   }
17566
17567   jresult = result;
17568   return jresult;
17569 }
17570
17571
17572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17573   unsigned int jresult ;
17574   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17575   Dali::Vector3 *arg2 = 0 ;
17576   bool result;
17577
17578   arg1 = (Dali::Property::Value *)jarg1;
17579   arg2 = (Dali::Vector3 *)jarg2;
17580   if (!arg2) {
17581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17582     return 0;
17583   }
17584   {
17585     try {
17586       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17587     } catch (std::out_of_range& e) {
17588       {
17589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (std::exception& e) {
17592       {
17593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17594       };
17595     } catch (Dali::DaliException e) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17598       };
17599     } catch (...) {
17600       {
17601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17602       };
17603     }
17604   }
17605
17606   jresult = result;
17607   return jresult;
17608 }
17609
17610
17611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17612   unsigned int jresult ;
17613   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17614   Dali::Vector4 *arg2 = 0 ;
17615   bool result;
17616
17617   arg1 = (Dali::Property::Value *)jarg1;
17618   arg2 = (Dali::Vector4 *)jarg2;
17619   if (!arg2) {
17620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17621     return 0;
17622   }
17623   {
17624     try {
17625       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17626     } catch (std::out_of_range& e) {
17627       {
17628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (std::exception& e) {
17631       {
17632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17633       };
17634     } catch (Dali::DaliException e) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17637       };
17638     } catch (...) {
17639       {
17640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17641       };
17642     }
17643   }
17644
17645   jresult = result;
17646   return jresult;
17647 }
17648
17649
17650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17651   unsigned int jresult ;
17652   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17653   Dali::Matrix3 *arg2 = 0 ;
17654   bool result;
17655
17656   arg1 = (Dali::Property::Value *)jarg1;
17657   arg2 = (Dali::Matrix3 *)jarg2;
17658   if (!arg2) {
17659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17660     return 0;
17661   }
17662   {
17663     try {
17664       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17665     } catch (std::out_of_range& e) {
17666       {
17667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (std::exception& e) {
17670       {
17671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17672       };
17673     } catch (Dali::DaliException e) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17676       };
17677     } catch (...) {
17678       {
17679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17680       };
17681     }
17682   }
17683
17684   jresult = result;
17685   return jresult;
17686 }
17687
17688
17689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17690   unsigned int jresult ;
17691   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17692   Dali::Matrix *arg2 = 0 ;
17693   bool result;
17694
17695   arg1 = (Dali::Property::Value *)jarg1;
17696   arg2 = (Dali::Matrix *)jarg2;
17697   if (!arg2) {
17698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17699     return 0;
17700   }
17701   {
17702     try {
17703       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17704     } catch (std::out_of_range& e) {
17705       {
17706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (std::exception& e) {
17709       {
17710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17711       };
17712     } catch (Dali::DaliException e) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17715       };
17716     } catch (...) {
17717       {
17718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17719       };
17720     }
17721   }
17722
17723   jresult = result;
17724   return jresult;
17725 }
17726
17727
17728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17729   unsigned int jresult ;
17730   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17731   Dali::AngleAxis *arg2 = 0 ;
17732   bool result;
17733
17734   arg1 = (Dali::Property::Value *)jarg1;
17735   arg2 = (Dali::AngleAxis *)jarg2;
17736   if (!arg2) {
17737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17738     return 0;
17739   }
17740   {
17741     try {
17742       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (Dali::DaliException e) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17754       };
17755     } catch (...) {
17756       {
17757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17758       };
17759     }
17760   }
17761
17762   jresult = result;
17763   return jresult;
17764 }
17765
17766
17767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17768   unsigned int jresult ;
17769   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17770   Dali::Quaternion *arg2 = 0 ;
17771   bool result;
17772
17773   arg1 = (Dali::Property::Value *)jarg1;
17774   arg2 = (Dali::Quaternion *)jarg2;
17775   if (!arg2) {
17776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17777     return 0;
17778   }
17779   {
17780     try {
17781       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17782     } catch (std::out_of_range& e) {
17783       {
17784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (std::exception& e) {
17787       {
17788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17789       };
17790     } catch (Dali::DaliException e) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17793       };
17794     } catch (...) {
17795       {
17796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17797       };
17798     }
17799   }
17800
17801   jresult = result;
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17807   unsigned int jresult ;
17808   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17809   std::string *arg2 = 0 ;
17810   bool result;
17811
17812   arg1 = (Dali::Property::Value *)jarg1;
17813
17814   //typemap in
17815   std::string temp;
17816   arg2 = &temp;
17817
17818   {
17819     try {
17820       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17821     } catch (std::out_of_range& e) {
17822       {
17823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (std::exception& e) {
17826       {
17827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17828       };
17829     } catch (Dali::DaliException e) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17832       };
17833     } catch (...) {
17834       {
17835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17836       };
17837     }
17838   }
17839
17840   jresult = result;
17841
17842   //Typemap argout in c++ file.
17843   //This will convert c++ string to c# string
17844   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17845
17846   return jresult;
17847 }
17848
17849
17850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17851   unsigned int jresult ;
17852   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17853   Dali::Property::Array *arg2 = 0 ;
17854   bool result;
17855
17856   arg1 = (Dali::Property::Value *)jarg1;
17857   arg2 = (Dali::Property::Array *)jarg2;
17858   if (!arg2) {
17859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17860     return 0;
17861   }
17862   {
17863     try {
17864       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17865     } catch (std::out_of_range& e) {
17866       {
17867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (std::exception& e) {
17870       {
17871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17872       };
17873     } catch (Dali::DaliException e) {
17874       {
17875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17880       };
17881     }
17882   }
17883
17884   jresult = result;
17885   return jresult;
17886 }
17887
17888
17889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17890   unsigned int jresult ;
17891   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17892   Dali::Property::Map *arg2 = 0 ;
17893   bool result;
17894
17895   arg1 = (Dali::Property::Value *)jarg1;
17896   arg2 = (Dali::Property::Map *)jarg2;
17897   if (!arg2) {
17898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17899     return 0;
17900   }
17901   {
17902     try {
17903       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17904     } catch (std::out_of_range& e) {
17905       {
17906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17907       };
17908     } catch (std::exception& e) {
17909       {
17910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17911       };
17912     } catch (Dali::DaliException e) {
17913       {
17914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17915       };
17916     } catch (...) {
17917       {
17918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17919       };
17920     }
17921   }
17922
17923   jresult = result;
17924   return jresult;
17925 }
17926
17927
17928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17929   unsigned int jresult ;
17930   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17931   Extents *arg2 = 0 ;
17932   bool result;
17933
17934   arg1 = (Dali::Property::Value *)jarg1;
17935   arg2 = (Extents *)jarg2;
17936   if (!arg2) {
17937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17938     return 0;
17939   }
17940   {
17941     try {
17942       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17943     } catch (std::out_of_range& e) {
17944       {
17945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (std::exception& e) {
17948       {
17949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957   jresult = result;
17958   return jresult;
17959 }
17960
17961
17962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17963   void * jresult ;
17964   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17965   Dali::Property::Array *result = 0 ;
17966
17967   arg1 = (Dali::Property::Value *)jarg1;
17968   {
17969     try {
17970       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17971     } catch (std::out_of_range& e) {
17972       {
17973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (std::exception& e) {
17976       {
17977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17978       };
17979     } catch (Dali::DaliException e) {
17980       {
17981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17982       };
17983     } catch (...) {
17984       {
17985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17986       };
17987     }
17988   }
17989
17990   jresult = (void *)result;
17991   return jresult;
17992 }
17993
17994
17995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17996   void * jresult ;
17997   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17998   Dali::Property::Map *result = 0 ;
17999
18000   arg1 = (Dali::Property::Value *)jarg1;
18001   {
18002     try {
18003       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18004     } catch (std::out_of_range& e) {
18005       {
18006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18007       };
18008     } catch (std::exception& e) {
18009       {
18010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18011       };
18012     } catch (Dali::DaliException e) {
18013       {
18014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18015       };
18016     } catch (...) {
18017       {
18018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18019       };
18020     }
18021   }
18022
18023   jresult = (void *)result;
18024   return jresult;
18025 }
18026
18027
18028 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18029   char * jresult ;
18030   Dali::Property::Type arg1 ;
18031   char *result = 0 ;
18032
18033   arg1 = (Dali::Property::Type)jarg1;
18034   {
18035     try {
18036       result = (char *)Dali::PropertyTypes::GetName(arg1);
18037     } catch (std::out_of_range& e) {
18038       {
18039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18040       };
18041     } catch (std::exception& e) {
18042       {
18043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18044       };
18045     } catch (Dali::DaliException e) {
18046       {
18047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18048       };
18049     } catch (...) {
18050       {
18051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18052       };
18053     }
18054   }
18055
18056   jresult = SWIG_csharp_string_callback((const char *)result);
18057   return jresult;
18058 }
18059
18060
18061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18062   unsigned int jresult ;
18063   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18064   std::string *arg2 = 0 ;
18065   Dali::Property::Map *arg3 = 0 ;
18066   bool result;
18067
18068   arg1 = (Dali::BaseObject *)jarg1;
18069   if (!jarg2) {
18070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18071     return 0;
18072   }
18073   std::string arg2_str(jarg2);
18074   arg2 = &arg2_str;
18075   arg3 = (Dali::Property::Map *)jarg3;
18076   if (!arg3) {
18077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18078     return 0;
18079   }
18080   {
18081     try {
18082       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18083     } catch (std::out_of_range& e) {
18084       {
18085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (std::exception& e) {
18088       {
18089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18090       };
18091     } catch (Dali::DaliException e) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18094       };
18095     } catch (...) {
18096       {
18097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18098       };
18099     }
18100   }
18101
18102   jresult = result;
18103
18104   //argout typemap for const std::string&
18105
18106   return jresult;
18107 }
18108
18109
18110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18111   char * jresult ;
18112   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18113   std::string *result = 0 ;
18114
18115   arg1 = (Dali::BaseObject *)jarg1;
18116   {
18117     try {
18118       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18119     } catch (std::out_of_range& e) {
18120       {
18121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (std::exception& e) {
18124       {
18125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (Dali::DaliException e) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137
18138   jresult = SWIG_csharp_string_callback(result->c_str());
18139   return jresult;
18140 }
18141
18142
18143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18144   unsigned int jresult ;
18145   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18146   Dali::TypeInfo *arg2 = 0 ;
18147   bool result;
18148
18149   arg1 = (Dali::BaseObject *)jarg1;
18150   arg2 = (Dali::TypeInfo *)jarg2;
18151   if (!arg2) {
18152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18153     return 0;
18154   }
18155   {
18156     try {
18157       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18158     } catch (std::out_of_range& e) {
18159       {
18160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (std::exception& e) {
18163       {
18164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18165       };
18166     } catch (Dali::DaliException e) {
18167       {
18168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18169       };
18170     } catch (...) {
18171       {
18172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18173       };
18174     }
18175   }
18176
18177   jresult = result;
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18183   unsigned int jresult ;
18184   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18185   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18186   std::string *arg3 = 0 ;
18187   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18188   bool result;
18189
18190   arg1 = (Dali::BaseObject *)jarg1;
18191   arg2 = (ConnectionTrackerInterface *)jarg2;
18192   if (!jarg3) {
18193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18194     return 0;
18195   }
18196   std::string arg3_str(jarg3);
18197   arg3 = &arg3_str;
18198   arg4 = (FunctorDelegate *)jarg4;
18199   {
18200     try {
18201       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18202     } catch (std::out_of_range& e) {
18203       {
18204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18205       };
18206     } catch (std::exception& e) {
18207       {
18208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18209       };
18210     } catch (Dali::DaliException e) {
18211       {
18212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18213       };
18214     } catch (...) {
18215       {
18216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18217       };
18218     }
18219   }
18220
18221   jresult = result;
18222
18223   //argout typemap for const std::string&
18224
18225   return jresult;
18226 }
18227
18228
18229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18230   void * jresult ;
18231   Dali::BaseHandle *arg1 = 0 ;
18232   Dali::BaseObject *result = 0 ;
18233
18234   arg1 = (Dali::BaseHandle *)jarg1;
18235   if (!arg1) {
18236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18237     return 0;
18238   }
18239   {
18240     try {
18241       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18242     } catch (std::out_of_range& e) {
18243       {
18244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (std::exception& e) {
18247       {
18248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18249       };
18250     } catch (Dali::DaliException e) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18253       };
18254     } catch (...) {
18255       {
18256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18257       };
18258     }
18259   }
18260
18261   jresult = (void *)result;
18262   return jresult;
18263 }
18264
18265
18266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18267   void * jresult ;
18268   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18269   Dali::BaseHandle *result = 0 ;
18270
18271   arg1 = (Dali::BaseObject *)jarg1;
18272   {
18273     try {
18274       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18275     } catch (std::out_of_range& e) {
18276       {
18277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (std::exception& e) {
18280       {
18281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18282       };
18283     } catch (Dali::DaliException e) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18286       };
18287     } catch (...) {
18288       {
18289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18290       };
18291     }
18292   }
18293
18294   jresult = (void *)result;
18295   return jresult;
18296 }
18297
18298
18299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18300   void * jresult ;
18301   Dali::BaseHandle *result = 0 ;
18302
18303   {
18304     try {
18305       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18306     } catch (std::out_of_range& e) {
18307       {
18308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18309       };
18310     } catch (std::exception& e) {
18311       {
18312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18313       };
18314     } catch (Dali::DaliException e) {
18315       {
18316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18317       };
18318     } catch (...) {
18319       {
18320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18321       };
18322     }
18323   }
18324
18325   jresult = (void *)result;
18326   return jresult;
18327 }
18328
18329
18330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18331   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18332
18333   arg1 = (Dali::BaseHandle *)jarg1;
18334   {
18335     try {
18336       delete arg1;
18337     } catch (std::out_of_range& e) {
18338       {
18339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18340       };
18341     } catch (std::exception& e) {
18342       {
18343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18344       };
18345     } catch (Dali::DaliException e) {
18346       {
18347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18348       };
18349     } catch (...) {
18350       {
18351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18352       };
18353     }
18354   }
18355
18356 }
18357
18358
18359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18360   void * jresult ;
18361   Dali::BaseHandle *arg1 = 0 ;
18362   Dali::BaseHandle *result = 0 ;
18363
18364   arg1 = (Dali::BaseHandle *)jarg1;
18365   if (!arg1) {
18366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18367     return 0;
18368   }
18369   {
18370     try {
18371       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18372     } catch (std::out_of_range& e) {
18373       {
18374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (std::exception& e) {
18377       {
18378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18379       };
18380     } catch (Dali::DaliException e) {
18381       {
18382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18383       };
18384     } catch (...) {
18385       {
18386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18387       };
18388     }
18389   }
18390
18391   jresult = (void *)result;
18392   return jresult;
18393 }
18394
18395
18396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18397   void * jresult ;
18398   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18399   Dali::BaseHandle *arg2 = 0 ;
18400   Dali::BaseHandle *result = 0 ;
18401
18402   arg1 = (Dali::BaseHandle *)jarg1;
18403   arg2 = (Dali::BaseHandle *)jarg2;
18404   if (!arg2) {
18405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18406     return 0;
18407   }
18408   {
18409     try {
18410       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18418       };
18419     } catch (Dali::DaliException e) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18422       };
18423     } catch (...) {
18424       {
18425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18426       };
18427     }
18428   }
18429
18430   jresult = (void *)result;
18431   return jresult;
18432 }
18433
18434
18435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18436   unsigned int jresult ;
18437   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18438   std::string *arg2 = 0 ;
18439   Dali::Property::Map *arg3 = 0 ;
18440   bool result;
18441
18442   arg1 = (Dali::BaseHandle *)jarg1;
18443   if (!jarg2) {
18444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18445     return 0;
18446   }
18447   std::string arg2_str(jarg2);
18448   arg2 = &arg2_str;
18449   arg3 = (Dali::Property::Map *)jarg3;
18450   if (!arg3) {
18451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18452     return 0;
18453   }
18454   {
18455     try {
18456       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18457     } catch (std::out_of_range& e) {
18458       {
18459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18460       };
18461     } catch (std::exception& e) {
18462       {
18463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18464       };
18465     } catch (Dali::DaliException e) {
18466       {
18467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18468       };
18469     } catch (...) {
18470       {
18471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18472       };
18473     }
18474   }
18475
18476   jresult = result;
18477
18478   //argout typemap for const std::string&
18479
18480   return jresult;
18481 }
18482
18483
18484 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18485   char * jresult ;
18486   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18487   std::string *result = 0 ;
18488
18489   arg1 = (Dali::BaseHandle *)jarg1;
18490   {
18491     try {
18492       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18500       };
18501     } catch (Dali::DaliException e) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18508       };
18509     }
18510   }
18511
18512   jresult = SWIG_csharp_string_callback(result->c_str());
18513   return jresult;
18514 }
18515
18516
18517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18518   unsigned int jresult ;
18519   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18520   Dali::TypeInfo *arg2 = 0 ;
18521   bool result;
18522
18523   arg1 = (Dali::BaseHandle *)jarg1;
18524   arg2 = (Dali::TypeInfo *)jarg2;
18525   if (!arg2) {
18526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18527     return 0;
18528   }
18529   {
18530     try {
18531       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18532     } catch (std::out_of_range& e) {
18533       {
18534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (std::exception& e) {
18537       {
18538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18539       };
18540     } catch (Dali::DaliException e) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18543       };
18544     } catch (...) {
18545       {
18546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18547       };
18548     }
18549   }
18550
18551   jresult = result;
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18557   void * jresult ;
18558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18559   Dali::BaseObject *result = 0 ;
18560
18561   arg1 = (Dali::BaseHandle *)jarg1;
18562   {
18563     try {
18564       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18565     } catch (std::out_of_range& e) {
18566       {
18567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (std::exception& e) {
18570       {
18571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18572       };
18573     } catch (Dali::DaliException e) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18576       };
18577     } catch (...) {
18578       {
18579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18580       };
18581     }
18582   }
18583
18584   jresult = (void *)result;
18585   return jresult;
18586 }
18587
18588
18589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18590   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18591
18592   arg1 = (Dali::BaseHandle *)jarg1;
18593   {
18594     try {
18595       (arg1)->Reset();
18596     } catch (std::out_of_range& e) {
18597       {
18598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18599       };
18600     } catch (std::exception& e) {
18601       {
18602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18603       };
18604     } catch (Dali::DaliException e) {
18605       {
18606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18607       };
18608     } catch (...) {
18609       {
18610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18611       };
18612     }
18613   }
18614
18615 }
18616
18617
18618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18619   unsigned int jresult ;
18620   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18621   Dali::BaseHandle *arg2 = 0 ;
18622   bool result;
18623
18624   arg1 = (Dali::BaseHandle *)jarg1;
18625   arg2 = (Dali::BaseHandle *)jarg2;
18626   if (!arg2) {
18627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18628     return 0;
18629   }
18630   {
18631     try {
18632       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18633     } catch (std::out_of_range& e) {
18634       {
18635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18636       };
18637     } catch (std::exception& e) {
18638       {
18639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (Dali::DaliException e) {
18642       {
18643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18644       };
18645     } catch (...) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18648       };
18649     }
18650   }
18651
18652   jresult = result;
18653   return jresult;
18654 }
18655
18656
18657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18658   unsigned int jresult ;
18659   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18660   Dali::BaseHandle *arg2 = 0 ;
18661   bool result;
18662
18663   arg1 = (Dali::BaseHandle *)jarg1;
18664   arg2 = (Dali::BaseHandle *)jarg2;
18665   if (!arg2) {
18666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18667     return 0;
18668   }
18669   {
18670     try {
18671       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18672     } catch (std::out_of_range& e) {
18673       {
18674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (std::exception& e) {
18677       {
18678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18679       };
18680     } catch (Dali::DaliException e) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18683       };
18684     } catch (...) {
18685       {
18686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18687       };
18688     }
18689   }
18690
18691   jresult = result;
18692   return jresult;
18693 }
18694
18695
18696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18697   void * jresult ;
18698   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18699   Dali::RefObject *result = 0 ;
18700
18701   arg1 = (Dali::BaseHandle *)jarg1;
18702   {
18703     try {
18704       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18705     } catch (std::out_of_range& e) {
18706       {
18707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (std::exception& e) {
18710       {
18711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18712       };
18713     } catch (Dali::DaliException e) {
18714       {
18715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18716       };
18717     } catch (...) {
18718       {
18719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18720       };
18721     }
18722   }
18723
18724   jresult = (void *)result;
18725   return jresult;
18726 }
18727
18728
18729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18730   unsigned int jresult ;
18731   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18732   bool result;
18733
18734   arg1 = (Dali::BaseHandle *)jarg1;
18735   {
18736     try {
18737       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18738     } catch (std::out_of_range& e) {
18739       {
18740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (std::exception& e) {
18743       {
18744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18745       };
18746     } catch (Dali::DaliException e) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18749       };
18750     } catch (...) {
18751       {
18752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18753       };
18754     }
18755   }
18756
18757   jresult = result;
18758   return jresult;
18759 }
18760
18761
18762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18763   unsigned int jresult ;
18764   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18765   Dali::BaseHandle *arg2 = 0 ;
18766   bool result;
18767
18768   arg1 = (Dali::BaseHandle *)jarg1;
18769   arg2 = (Dali::BaseHandle *)jarg2;
18770   if (!arg2) {
18771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18772     return 0;
18773   }
18774   {
18775     try {
18776       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18777     } catch (std::out_of_range& e) {
18778       {
18779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (std::exception& e) {
18782       {
18783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18784       };
18785     } catch (Dali::DaliException e) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18788       };
18789     } catch (...) {
18790       {
18791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18792       };
18793     }
18794   }
18795
18796   jresult = result;
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18802   unsigned int jresult ;
18803   Dali::BaseHandle *arg1 = 0 ;
18804   Dali::BaseHandle *arg2 = 0 ;
18805   bool result;
18806
18807   arg1 = (Dali::BaseHandle *)jarg1;
18808   if (!arg1) {
18809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18810     return 0;
18811   }
18812   arg2 = (Dali::BaseHandle *)jarg2;
18813   if (!arg2) {
18814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18815     return 0;
18816   }
18817   {
18818     try {
18819       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18820     } catch (std::out_of_range& e) {
18821       {
18822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (std::exception& e) {
18825       {
18826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18827       };
18828     } catch (Dali::DaliException e) {
18829       {
18830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18831       };
18832     } catch (...) {
18833       {
18834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18835       };
18836     }
18837   }
18838
18839   jresult = result;
18840   return jresult;
18841 }
18842
18843
18844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18845   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18846
18847   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18848   {
18849     try {
18850       delete arg1;
18851     } catch (std::out_of_range& e) {
18852       {
18853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18854       };
18855     } catch (std::exception& e) {
18856       {
18857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18858       };
18859     } catch (Dali::DaliException e) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18866       };
18867     }
18868   }
18869
18870 }
18871
18872
18873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18874   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18875   SlotObserver *arg2 = (SlotObserver *) 0 ;
18876   CallbackBase *arg3 = (CallbackBase *) 0 ;
18877
18878   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18879   arg2 = (SlotObserver *)jarg2;
18880   arg3 = (CallbackBase *)jarg3;
18881   {
18882     try {
18883       (arg1)->SignalConnected(arg2,arg3);
18884     } catch (std::out_of_range& e) {
18885       {
18886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18887       };
18888     } catch (std::exception& e) {
18889       {
18890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18891       };
18892     } catch (Dali::DaliException e) {
18893       {
18894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18895       };
18896     } catch (...) {
18897       {
18898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18899       };
18900     }
18901   }
18902
18903 }
18904
18905
18906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18907   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18908
18909   arg1 = (Dali::SignalObserver *)jarg1;
18910   {
18911     try {
18912       delete arg1;
18913     } catch (std::out_of_range& e) {
18914       {
18915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18916       };
18917     } catch (std::exception& e) {
18918       {
18919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18920       };
18921     } catch (Dali::DaliException e) {
18922       {
18923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18924       };
18925     } catch (...) {
18926       {
18927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18928       };
18929     }
18930   }
18931
18932 }
18933
18934
18935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18936   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18937   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18938   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18939
18940   arg1 = (Dali::SignalObserver *)jarg1;
18941   arg2 = (Dali::SlotObserver *)jarg2;
18942   arg3 = (Dali::CallbackBase *)jarg3;
18943   {
18944     try {
18945       (arg1)->SignalDisconnected(arg2,arg3);
18946     } catch (std::out_of_range& e) {
18947       {
18948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18949       };
18950     } catch (std::exception& e) {
18951       {
18952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18953       };
18954     } catch (Dali::DaliException e) {
18955       {
18956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18957       };
18958     } catch (...) {
18959       {
18960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18961       };
18962     }
18963   }
18964
18965 }
18966
18967
18968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18969   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18970
18971   arg1 = (Dali::SlotObserver *)jarg1;
18972   {
18973     try {
18974       delete arg1;
18975     } catch (std::out_of_range& e) {
18976       {
18977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18978       };
18979     } catch (std::exception& e) {
18980       {
18981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18982       };
18983     } catch (Dali::DaliException e) {
18984       {
18985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18986       };
18987     } catch (...) {
18988       {
18989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18990       };
18991     }
18992   }
18993
18994 }
18995
18996
18997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18998   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18999   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19000
19001   arg1 = (Dali::SlotObserver *)jarg1;
19002   arg2 = (Dali::CallbackBase *)jarg2;
19003   {
19004     try {
19005       (arg1)->SlotDisconnected(arg2);
19006     } catch (std::out_of_range& e) {
19007       {
19008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (std::exception& e) {
19011       {
19012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19013       };
19014     } catch (Dali::DaliException e) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19017       };
19018     } catch (...) {
19019       {
19020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19021       };
19022     }
19023   }
19024
19025 }
19026
19027
19028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19029   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19030
19031   arg1 = (Dali::ConnectionTracker *)jarg1;
19032   {
19033     try {
19034       delete arg1;
19035     } catch (std::out_of_range& e) {
19036       {
19037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (std::exception& e) {
19040       {
19041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19042       };
19043     } catch (Dali::DaliException e) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19046       };
19047     } catch (...) {
19048       {
19049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19050       };
19051     }
19052   }
19053
19054 }
19055
19056
19057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19058   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19059
19060   arg1 = (Dali::ConnectionTracker *)jarg1;
19061   {
19062     try {
19063       (arg1)->DisconnectAll();
19064     } catch (std::out_of_range& e) {
19065       {
19066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19067       };
19068     } catch (std::exception& e) {
19069       {
19070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19071       };
19072     } catch (Dali::DaliException e) {
19073       {
19074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19075       };
19076     } catch (...) {
19077       {
19078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19079       };
19080     }
19081   }
19082
19083 }
19084
19085
19086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19087   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19088   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19089   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19090
19091   arg1 = (Dali::ConnectionTracker *)jarg1;
19092   arg2 = (Dali::SlotObserver *)jarg2;
19093   arg3 = (Dali::CallbackBase *)jarg3;
19094   {
19095     try {
19096       (arg1)->SignalConnected(arg2,arg3);
19097     } catch (std::out_of_range& e) {
19098       {
19099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (std::exception& e) {
19102       {
19103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19104       };
19105     } catch (Dali::DaliException e) {
19106       {
19107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19108       };
19109     } catch (...) {
19110       {
19111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19112       };
19113     }
19114   }
19115
19116 }
19117
19118
19119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19120   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19121   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19122   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19123
19124   arg1 = (Dali::ConnectionTracker *)jarg1;
19125   arg2 = (Dali::SlotObserver *)jarg2;
19126   arg3 = (Dali::CallbackBase *)jarg3;
19127   {
19128     try {
19129       (arg1)->SignalDisconnected(arg2,arg3);
19130     } catch (std::out_of_range& e) {
19131       {
19132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19133       };
19134     } catch (std::exception& e) {
19135       {
19136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19137       };
19138     } catch (Dali::DaliException e) {
19139       {
19140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19141       };
19142     } catch (...) {
19143       {
19144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19145       };
19146     }
19147   }
19148
19149 }
19150
19151
19152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19153   unsigned long jresult ;
19154   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19155   std::size_t result;
19156
19157   arg1 = (Dali::ConnectionTracker *)jarg1;
19158   {
19159     try {
19160       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19161     } catch (std::out_of_range& e) {
19162       {
19163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (std::exception& e) {
19166       {
19167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19168       };
19169     } catch (Dali::DaliException e) {
19170       {
19171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19172       };
19173     } catch (...) {
19174       {
19175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19176       };
19177     }
19178   }
19179
19180   jresult = (unsigned long)result;
19181   return jresult;
19182 }
19183
19184
19185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19186   void * jresult ;
19187   Dali::ObjectRegistry *result = 0 ;
19188
19189   {
19190     try {
19191       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (Dali::DaliException e) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19203       };
19204     } catch (...) {
19205       {
19206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19207       };
19208     }
19209   }
19210
19211   jresult = (void *)result;
19212   return jresult;
19213 }
19214
19215
19216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19217   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19218
19219   arg1 = (Dali::ObjectRegistry *)jarg1;
19220   {
19221     try {
19222       delete arg1;
19223     } catch (std::out_of_range& e) {
19224       {
19225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19226       };
19227     } catch (std::exception& e) {
19228       {
19229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19230       };
19231     } catch (Dali::DaliException e) {
19232       {
19233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19234       };
19235     } catch (...) {
19236       {
19237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19238       };
19239     }
19240   }
19241
19242 }
19243
19244
19245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19246   void * jresult ;
19247   Dali::ObjectRegistry *arg1 = 0 ;
19248   Dali::ObjectRegistry *result = 0 ;
19249
19250   arg1 = (Dali::ObjectRegistry *)jarg1;
19251   if (!arg1) {
19252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19253     return 0;
19254   }
19255   {
19256     try {
19257       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19258     } catch (std::out_of_range& e) {
19259       {
19260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (std::exception& e) {
19263       {
19264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19265       };
19266     } catch (Dali::DaliException e) {
19267       {
19268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19269       };
19270     } catch (...) {
19271       {
19272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19273       };
19274     }
19275   }
19276
19277   jresult = (void *)result;
19278   return jresult;
19279 }
19280
19281
19282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19283   void * jresult ;
19284   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19285   Dali::ObjectRegistry *arg2 = 0 ;
19286   Dali::ObjectRegistry *result = 0 ;
19287
19288   arg1 = (Dali::ObjectRegistry *)jarg1;
19289   arg2 = (Dali::ObjectRegistry *)jarg2;
19290   if (!arg2) {
19291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19292     return 0;
19293   }
19294   {
19295     try {
19296       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19304       };
19305     } catch (Dali::DaliException e) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19308       };
19309     } catch (...) {
19310       {
19311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19312       };
19313     }
19314   }
19315
19316   jresult = (void *)result;
19317   return jresult;
19318 }
19319
19320
19321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19322   void * jresult ;
19323   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19324   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19325
19326   arg1 = (Dali::ObjectRegistry *)jarg1;
19327   {
19328     try {
19329       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19330     } catch (std::out_of_range& e) {
19331       {
19332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19333       };
19334     } catch (std::exception& e) {
19335       {
19336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19337       };
19338     } catch (Dali::DaliException e) {
19339       {
19340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19341       };
19342     } catch (...) {
19343       {
19344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19345       };
19346     }
19347   }
19348
19349   jresult = (void *)result;
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19355   void * jresult ;
19356   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19357   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19358
19359   arg1 = (Dali::ObjectRegistry *)jarg1;
19360   {
19361     try {
19362       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19363     } catch (std::out_of_range& e) {
19364       {
19365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (std::exception& e) {
19368       {
19369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19370       };
19371     } catch (Dali::DaliException e) {
19372       {
19373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19374       };
19375     } catch (...) {
19376       {
19377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19378       };
19379     }
19380   }
19381
19382   jresult = (void *)result;
19383   return jresult;
19384 }
19385
19386
19387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19388   void * jresult ;
19389   Dali::PropertyCondition *result = 0 ;
19390
19391   {
19392     try {
19393       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19394     } catch (std::out_of_range& e) {
19395       {
19396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (std::exception& e) {
19399       {
19400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19401       };
19402     } catch (Dali::DaliException e) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19405       };
19406     } catch (...) {
19407       {
19408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19409       };
19410     }
19411   }
19412
19413   jresult = (void *)result;
19414   return jresult;
19415 }
19416
19417
19418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19419   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19420
19421   arg1 = (Dali::PropertyCondition *)jarg1;
19422   {
19423     try {
19424       delete arg1;
19425     } catch (std::out_of_range& e) {
19426       {
19427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19428       };
19429     } catch (std::exception& e) {
19430       {
19431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19432       };
19433     } catch (Dali::DaliException e) {
19434       {
19435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19436       };
19437     } catch (...) {
19438       {
19439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19440       };
19441     }
19442   }
19443
19444 }
19445
19446
19447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19448   void * jresult ;
19449   Dali::PropertyCondition *arg1 = 0 ;
19450   Dali::PropertyCondition *result = 0 ;
19451
19452   arg1 = (Dali::PropertyCondition *)jarg1;
19453   if (!arg1) {
19454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19455     return 0;
19456   }
19457   {
19458     try {
19459       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19460     } catch (std::out_of_range& e) {
19461       {
19462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19463       };
19464     } catch (std::exception& e) {
19465       {
19466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19467       };
19468     } catch (Dali::DaliException e) {
19469       {
19470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19471       };
19472     } catch (...) {
19473       {
19474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19475       };
19476     }
19477   }
19478
19479   jresult = (void *)result;
19480   return jresult;
19481 }
19482
19483
19484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19485   void * jresult ;
19486   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19487   Dali::PropertyCondition *arg2 = 0 ;
19488   Dali::PropertyCondition *result = 0 ;
19489
19490   arg1 = (Dali::PropertyCondition *)jarg1;
19491   arg2 = (Dali::PropertyCondition *)jarg2;
19492   if (!arg2) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19494     return 0;
19495   }
19496   {
19497     try {
19498       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19499     } catch (std::out_of_range& e) {
19500       {
19501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19502       };
19503     } catch (std::exception& e) {
19504       {
19505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19506       };
19507     } catch (Dali::DaliException e) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19510       };
19511     } catch (...) {
19512       {
19513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19514       };
19515     }
19516   }
19517
19518   jresult = (void *)result;
19519   return jresult;
19520 }
19521
19522
19523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19524   unsigned long jresult ;
19525   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19526   std::size_t result;
19527
19528   arg1 = (Dali::PropertyCondition *)jarg1;
19529   {
19530     try {
19531       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19532     } catch (std::out_of_range& e) {
19533       {
19534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (std::exception& e) {
19537       {
19538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19539       };
19540     } catch (...) {
19541       {
19542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19543       };
19544     }
19545   }
19546   jresult = (unsigned long)result;
19547   return jresult;
19548 }
19549
19550
19551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19552   float jresult ;
19553   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19554   std::size_t arg2 ;
19555   float result;
19556
19557   arg1 = (Dali::PropertyCondition *)jarg1;
19558   arg2 = (std::size_t)jarg2;
19559   {
19560     try {
19561       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19562     } catch (std::out_of_range& e) {
19563       {
19564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19565       };
19566     } catch (std::exception& e) {
19567       {
19568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19569       };
19570     } catch (...) {
19571       {
19572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19573       };
19574     }
19575   }
19576   jresult = result;
19577   return jresult;
19578 }
19579
19580
19581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19582   void * jresult ;
19583   float arg1 ;
19584   Dali::PropertyCondition result;
19585
19586   arg1 = (float)jarg1;
19587   {
19588     try {
19589       result = Dali::LessThanCondition(arg1);
19590     } catch (std::out_of_range& e) {
19591       {
19592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (std::exception& e) {
19595       {
19596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19597       };
19598     } catch (Dali::DaliException e) {
19599       {
19600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19601       };
19602     } catch (...) {
19603       {
19604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19605       };
19606     }
19607   }
19608
19609   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19610   return jresult;
19611 }
19612
19613
19614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19615   void * jresult ;
19616   float arg1 ;
19617   Dali::PropertyCondition result;
19618
19619   arg1 = (float)jarg1;
19620   {
19621     try {
19622       result = Dali::GreaterThanCondition(arg1);
19623     } catch (std::out_of_range& e) {
19624       {
19625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19626       };
19627     } catch (std::exception& e) {
19628       {
19629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19630       };
19631     } catch (Dali::DaliException e) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19634       };
19635     } catch (...) {
19636       {
19637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19638       };
19639     }
19640   }
19641
19642   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19643   return jresult;
19644 }
19645
19646
19647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19648   void * jresult ;
19649   float arg1 ;
19650   float arg2 ;
19651   Dali::PropertyCondition result;
19652
19653   arg1 = (float)jarg1;
19654   arg2 = (float)jarg2;
19655   {
19656     try {
19657       result = Dali::InsideCondition(arg1,arg2);
19658     } catch (std::out_of_range& e) {
19659       {
19660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (std::exception& e) {
19663       {
19664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (Dali::DaliException e) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19669       };
19670     } catch (...) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19673       };
19674     }
19675   }
19676
19677   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19678   return jresult;
19679 }
19680
19681
19682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19683   void * jresult ;
19684   float arg1 ;
19685   float arg2 ;
19686   Dali::PropertyCondition result;
19687
19688   arg1 = (float)jarg1;
19689   arg2 = (float)jarg2;
19690   {
19691     try {
19692       result = Dali::OutsideCondition(arg1,arg2);
19693     } catch (std::out_of_range& e) {
19694       {
19695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19696       };
19697     } catch (std::exception& e) {
19698       {
19699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19700       };
19701     } catch (Dali::DaliException e) {
19702       {
19703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19704       };
19705     } catch (...) {
19706       {
19707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19708       };
19709     }
19710   }
19711
19712   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19713   return jresult;
19714 }
19715
19716
19717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19718   void * jresult ;
19719   float arg1 ;
19720   float arg2 ;
19721   Dali::PropertyCondition result;
19722
19723   arg1 = (float)jarg1;
19724   arg2 = (float)jarg2;
19725   {
19726     try {
19727       result = Dali::StepCondition(arg1,arg2);
19728     } catch (std::out_of_range& e) {
19729       {
19730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (std::exception& e) {
19733       {
19734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (Dali::DaliException e) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19739       };
19740     } catch (...) {
19741       {
19742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19743       };
19744     }
19745   }
19746
19747   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19748   return jresult;
19749 }
19750
19751
19752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19753   void * jresult ;
19754   float arg1 ;
19755   Dali::PropertyCondition result;
19756
19757   arg1 = (float)jarg1;
19758   {
19759     try {
19760       result = Dali::StepCondition(arg1);
19761     } catch (std::out_of_range& e) {
19762       {
19763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19764       };
19765     } catch (std::exception& e) {
19766       {
19767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19768       };
19769     } catch (Dali::DaliException e) {
19770       {
19771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19772       };
19773     } catch (...) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19776       };
19777     }
19778   }
19779
19780   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19781   return jresult;
19782 }
19783
19784
19785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19786   void * jresult ;
19787   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19788   Dali::PropertyCondition result;
19789
19790   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19791   if (!arg1) {
19792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19793     return 0;
19794   }
19795   {
19796     try {
19797       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19798     } catch (std::out_of_range& e) {
19799       {
19800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (std::exception& e) {
19803       {
19804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (Dali::DaliException e) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19809       };
19810     } catch (...) {
19811       {
19812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19813       };
19814     }
19815   }
19816
19817   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19818   return jresult;
19819 }
19820
19821
19822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19823   void * jresult ;
19824   Dali::PropertyNotification *result = 0 ;
19825
19826   {
19827     try {
19828       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19829     } catch (std::out_of_range& e) {
19830       {
19831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19832       };
19833     } catch (std::exception& e) {
19834       {
19835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19836       };
19837     } catch (Dali::DaliException e) {
19838       {
19839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19840       };
19841     } catch (...) {
19842       {
19843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19844       };
19845     }
19846   }
19847
19848   jresult = (void *)result;
19849   return jresult;
19850 }
19851
19852
19853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19854   void * jresult ;
19855   Dali::BaseHandle arg1 ;
19856   Dali::BaseHandle *argp1 ;
19857   Dali::PropertyNotification result;
19858
19859   argp1 = (Dali::BaseHandle *)jarg1;
19860   if (!argp1) {
19861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19862     return 0;
19863   }
19864   arg1 = *argp1;
19865   {
19866     try {
19867       result = Dali::PropertyNotification::DownCast(arg1);
19868     } catch (std::out_of_range& e) {
19869       {
19870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (std::exception& e) {
19873       {
19874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (Dali::DaliException e) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19879       };
19880     } catch (...) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19883       };
19884     }
19885   }
19886
19887   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19893   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19894
19895   arg1 = (Dali::PropertyNotification *)jarg1;
19896   {
19897     try {
19898       delete arg1;
19899     } catch (std::out_of_range& e) {
19900       {
19901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (std::exception& e) {
19904       {
19905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19906       };
19907     } catch (Dali::DaliException e) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19910       };
19911     } catch (...) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19914       };
19915     }
19916   }
19917
19918 }
19919
19920
19921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19922   void * jresult ;
19923   Dali::PropertyNotification *arg1 = 0 ;
19924   Dali::PropertyNotification *result = 0 ;
19925
19926   arg1 = (Dali::PropertyNotification *)jarg1;
19927   if (!arg1) {
19928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19929     return 0;
19930   }
19931   {
19932     try {
19933       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19934     } catch (std::out_of_range& e) {
19935       {
19936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (std::exception& e) {
19939       {
19940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19941       };
19942     } catch (Dali::DaliException e) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19945       };
19946     } catch (...) {
19947       {
19948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19949       };
19950     }
19951   }
19952
19953   jresult = (void *)result;
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19959   void * jresult ;
19960   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19961   Dali::PropertyNotification *arg2 = 0 ;
19962   Dali::PropertyNotification *result = 0 ;
19963
19964   arg1 = (Dali::PropertyNotification *)jarg1;
19965   arg2 = (Dali::PropertyNotification *)jarg2;
19966   if (!arg2) {
19967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19968     return 0;
19969   }
19970   {
19971     try {
19972       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19973     } catch (std::out_of_range& e) {
19974       {
19975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19976       };
19977     } catch (std::exception& e) {
19978       {
19979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19980       };
19981     } catch (Dali::DaliException e) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19984       };
19985     } catch (...) {
19986       {
19987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19988       };
19989     }
19990   }
19991
19992   jresult = (void *)result;
19993   return jresult;
19994 }
19995
19996
19997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19998   void * jresult ;
19999   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20000   Dali::PropertyCondition result;
20001
20002   arg1 = (Dali::PropertyNotification *)jarg1;
20003   {
20004     try {
20005       result = (arg1)->GetCondition();
20006     } catch (std::out_of_range& e) {
20007       {
20008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (std::exception& e) {
20011       {
20012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20013       };
20014     } catch (Dali::DaliException e) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20017       };
20018     } catch (...) {
20019       {
20020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20021       };
20022     }
20023   }
20024
20025   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20031   void * jresult ;
20032   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20033   Dali::Handle result;
20034
20035   arg1 = (Dali::PropertyNotification *)jarg1;
20036   {
20037     try {
20038       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20039     } catch (std::out_of_range& e) {
20040       {
20041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20042       };
20043     } catch (std::exception& e) {
20044       {
20045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20046       };
20047     } catch (Dali::DaliException e) {
20048       {
20049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20050       };
20051     } catch (...) {
20052       {
20053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20054       };
20055     }
20056   }
20057
20058   jresult = new Dali::Handle((const Dali::Handle &)result);
20059   return jresult;
20060 }
20061
20062
20063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20064   int jresult ;
20065   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20066   Dali::Property::Index result;
20067
20068   arg1 = (Dali::PropertyNotification *)jarg1;
20069   {
20070     try {
20071       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20072     } catch (std::out_of_range& e) {
20073       {
20074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20075       };
20076     } catch (std::exception& e) {
20077       {
20078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20079       };
20080     } catch (Dali::DaliException e) {
20081       {
20082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20083       };
20084     } catch (...) {
20085       {
20086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20087       };
20088     }
20089   }
20090
20091   jresult = result;
20092   return jresult;
20093 }
20094
20095
20096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20097   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20098   Dali::PropertyNotification::NotifyMode arg2 ;
20099
20100   arg1 = (Dali::PropertyNotification *)jarg1;
20101   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20102   {
20103     try {
20104       (arg1)->SetNotifyMode(arg2);
20105     } catch (std::out_of_range& e) {
20106       {
20107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20108       };
20109     } catch (std::exception& e) {
20110       {
20111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20112       };
20113     } catch (Dali::DaliException e) {
20114       {
20115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20116       };
20117     } catch (...) {
20118       {
20119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20120       };
20121     }
20122   }
20123
20124 }
20125
20126
20127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20128   int jresult ;
20129   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20130   Dali::PropertyNotification::NotifyMode result;
20131
20132   arg1 = (Dali::PropertyNotification *)jarg1;
20133   {
20134     try {
20135       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20136     } catch (std::out_of_range& e) {
20137       {
20138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20139       };
20140     } catch (std::exception& e) {
20141       {
20142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20143       };
20144     } catch (Dali::DaliException e) {
20145       {
20146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20147       };
20148     } catch (...) {
20149       {
20150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20151       };
20152     }
20153   }
20154
20155   jresult = (int)result;
20156   return jresult;
20157 }
20158
20159
20160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20161   unsigned int jresult ;
20162   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20163   bool result;
20164
20165   arg1 = (Dali::PropertyNotification *)jarg1;
20166   {
20167     try {
20168       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20169     } catch (std::out_of_range& e) {
20170       {
20171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20172       };
20173     } catch (std::exception& e) {
20174       {
20175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20176       };
20177     } catch (Dali::DaliException e) {
20178       {
20179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20180       };
20181     } catch (...) {
20182       {
20183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20184       };
20185     }
20186   }
20187
20188   jresult = result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20194   void * jresult ;
20195   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20196   Dali::PropertyNotifySignalType *result = 0 ;
20197
20198   arg1 = (Dali::PropertyNotification *)jarg1;
20199   {
20200     try {
20201       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20202     } catch (std::out_of_range& e) {
20203       {
20204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20205       };
20206     } catch (std::exception& e) {
20207       {
20208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20209       };
20210     } catch (Dali::DaliException e) {
20211       {
20212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20213       };
20214     } catch (...) {
20215       {
20216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20217       };
20218     }
20219   }
20220
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20227   void * jresult ;
20228   Dali::Handle *result = 0 ;
20229
20230   {
20231     try {
20232       result = (Dali::Handle *)new Dali::Handle();
20233     } catch (std::out_of_range& e) {
20234       {
20235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20236       };
20237     } catch (std::exception& e) {
20238       {
20239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20240       };
20241     } catch (Dali::DaliException e) {
20242       {
20243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20244       };
20245     } catch (...) {
20246       {
20247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20248       };
20249     }
20250   }
20251
20252   jresult = (void *)result;
20253   return jresult;
20254 }
20255
20256
20257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20258   void * jresult ;
20259   Dali::Handle result;
20260
20261   {
20262     try {
20263       result = Dali::Handle::New();
20264     } catch (std::out_of_range& e) {
20265       {
20266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20267       };
20268     } catch (std::exception& e) {
20269       {
20270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20271       };
20272     } catch (Dali::DaliException e) {
20273       {
20274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20275       };
20276     } catch (...) {
20277       {
20278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20279       };
20280     }
20281   }
20282
20283   jresult = new Dali::Handle((const Dali::Handle &)result);
20284   return jresult;
20285 }
20286
20287
20288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20289   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20290
20291   arg1 = (Dali::Handle *)jarg1;
20292   {
20293     try {
20294       delete arg1;
20295     } catch (std::out_of_range& e) {
20296       {
20297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20298       };
20299     } catch (std::exception& e) {
20300       {
20301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20302       };
20303     } catch (Dali::DaliException e) {
20304       {
20305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20306       };
20307     } catch (...) {
20308       {
20309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20310       };
20311     }
20312   }
20313
20314 }
20315
20316
20317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20318   void * jresult ;
20319   Dali::Handle *arg1 = 0 ;
20320   Dali::Handle *result = 0 ;
20321
20322   arg1 = (Dali::Handle *)jarg1;
20323   if (!arg1) {
20324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20325     return 0;
20326   }
20327   {
20328     try {
20329       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20330     } catch (std::out_of_range& e) {
20331       {
20332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20333       };
20334     } catch (std::exception& e) {
20335       {
20336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20337       };
20338     } catch (Dali::DaliException e) {
20339       {
20340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20341       };
20342     } catch (...) {
20343       {
20344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20345       };
20346     }
20347   }
20348
20349   jresult = (void *)result;
20350   return jresult;
20351 }
20352
20353
20354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20355   void * jresult ;
20356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20357   Dali::Handle *arg2 = 0 ;
20358   Dali::Handle *result = 0 ;
20359
20360   arg1 = (Dali::Handle *)jarg1;
20361   arg2 = (Dali::Handle *)jarg2;
20362   if (!arg2) {
20363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20364     return 0;
20365   }
20366   {
20367     try {
20368       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20369     } catch (std::out_of_range& e) {
20370       {
20371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20372       };
20373     } catch (std::exception& e) {
20374       {
20375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20376       };
20377     } catch (Dali::DaliException e) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20380       };
20381     } catch (...) {
20382       {
20383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20384       };
20385     }
20386   }
20387
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20394   void * jresult ;
20395   Dali::BaseHandle arg1 ;
20396   Dali::BaseHandle *argp1 ;
20397   Dali::Handle result;
20398
20399   argp1 = (Dali::BaseHandle *)jarg1;
20400   if (!argp1) {
20401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20402     return 0;
20403   }
20404   arg1 = *argp1;
20405   {
20406     try {
20407       result = Dali::Handle::DownCast(arg1);
20408     } catch (std::out_of_range& e) {
20409       {
20410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (std::exception& e) {
20413       {
20414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20415       };
20416     } catch (Dali::DaliException e) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20419       };
20420     } catch (...) {
20421       {
20422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20423       };
20424     }
20425   }
20426
20427   jresult = new Dali::Handle((const Dali::Handle &)result);
20428   return jresult;
20429 }
20430
20431
20432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20433   unsigned int jresult ;
20434   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20435   Dali::Handle::Capability arg2 ;
20436   bool result;
20437
20438   arg1 = (Dali::Handle *)jarg1;
20439   arg2 = (Dali::Handle::Capability)jarg2;
20440   {
20441     try {
20442       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20443     } catch (std::out_of_range& e) {
20444       {
20445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (std::exception& e) {
20448       {
20449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20450       };
20451     } catch (Dali::DaliException e) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20454       };
20455     } catch (...) {
20456       {
20457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20458       };
20459     }
20460   }
20461
20462   jresult = result;
20463   return jresult;
20464 }
20465
20466
20467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20468   unsigned int jresult ;
20469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20470   unsigned int result;
20471
20472   arg1 = (Dali::Handle *)jarg1;
20473   {
20474     try {
20475       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20476     } catch (std::out_of_range& e) {
20477       {
20478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20479       };
20480     } catch (std::exception& e) {
20481       {
20482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20483       };
20484     } catch (Dali::DaliException e) {
20485       {
20486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20487       };
20488     } catch (...) {
20489       {
20490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20491       };
20492     }
20493   }
20494
20495   jresult = result;
20496   return jresult;
20497 }
20498
20499
20500 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20501   char * jresult ;
20502   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20503   Dali::Property::Index arg2 ;
20504   std::string result;
20505
20506   arg1 = (Dali::Handle *)jarg1;
20507   arg2 = (Dali::Property::Index)jarg2;
20508   {
20509     try {
20510       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20511     } catch (std::out_of_range& e) {
20512       {
20513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20514       };
20515     } catch (std::exception& e) {
20516       {
20517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20518       };
20519     } catch (Dali::DaliException e) {
20520       {
20521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20522       };
20523     } catch (...) {
20524       {
20525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20526       };
20527     }
20528   }
20529
20530   jresult = SWIG_csharp_string_callback((&result)->c_str());
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20536   int jresult ;
20537   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20538   std::string *arg2 = 0 ;
20539   Dali::Property::Index result;
20540
20541   arg1 = (Dali::Handle *)jarg1;
20542   if (!jarg2) {
20543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20544     return 0;
20545   }
20546   std::string arg2_str(jarg2);
20547   arg2 = &arg2_str;
20548   {
20549     try {
20550       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20551     } catch (std::out_of_range& e) {
20552       {
20553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (std::exception& e) {
20556       {
20557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20558       };
20559     } catch (Dali::DaliException e) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20562       };
20563     } catch (...) {
20564       {
20565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20566       };
20567     }
20568   }
20569
20570   jresult = result;
20571
20572   //argout typemap for const std::string&
20573
20574   return jresult;
20575 }
20576
20577
20578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20579   unsigned int jresult ;
20580   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20581   Dali::Property::Index arg2 ;
20582   bool result;
20583
20584   arg1 = (Dali::Handle *)jarg1;
20585   arg2 = (Dali::Property::Index)jarg2;
20586   {
20587     try {
20588       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20589     } catch (std::out_of_range& e) {
20590       {
20591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (std::exception& e) {
20594       {
20595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (Dali::DaliException e) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20600       };
20601     } catch (...) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20604       };
20605     }
20606   }
20607
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20614   unsigned int jresult ;
20615   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20616   Dali::Property::Index arg2 ;
20617   bool result;
20618
20619   arg1 = (Dali::Handle *)jarg1;
20620   arg2 = (Dali::Property::Index)jarg2;
20621   {
20622     try {
20623       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20624     } catch (std::out_of_range& e) {
20625       {
20626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (std::exception& e) {
20629       {
20630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20631       };
20632     } catch (Dali::DaliException e) {
20633       {
20634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20635       };
20636     } catch (...) {
20637       {
20638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20639       };
20640     }
20641   }
20642
20643   jresult = result;
20644   return jresult;
20645 }
20646
20647
20648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20649   unsigned int jresult ;
20650   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20651   Dali::Property::Index arg2 ;
20652   bool result;
20653
20654   arg1 = (Dali::Handle *)jarg1;
20655   arg2 = (Dali::Property::Index)jarg2;
20656   {
20657     try {
20658       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20659     } catch (std::out_of_range& e) {
20660       {
20661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20662       };
20663     } catch (std::exception& e) {
20664       {
20665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20666       };
20667     } catch (Dali::DaliException e) {
20668       {
20669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20670       };
20671     } catch (...) {
20672       {
20673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20674       };
20675     }
20676   }
20677
20678   jresult = result;
20679   return jresult;
20680 }
20681
20682
20683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20684   int jresult ;
20685   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20686   Dali::Property::Index arg2 ;
20687   Dali::Property::Type result;
20688
20689   arg1 = (Dali::Handle *)jarg1;
20690   arg2 = (Dali::Property::Index)jarg2;
20691   {
20692     try {
20693       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20694     } catch (std::out_of_range& e) {
20695       {
20696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (std::exception& e) {
20699       {
20700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (Dali::DaliException e) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712
20713   jresult = (int)result;
20714   return jresult;
20715 }
20716
20717
20718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20719   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20720   Dali::Property::Index arg2 ;
20721   Dali::Property::Value *arg3 = 0 ;
20722
20723   arg1 = (Dali::Handle *)jarg1;
20724   arg2 = (Dali::Property::Index)jarg2;
20725   arg3 = (Dali::Property::Value *)jarg3;
20726   if (!arg3) {
20727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20728     return ;
20729   }
20730   {
20731     try {
20732       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20733     } catch (std::out_of_range& e) {
20734       {
20735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20736       };
20737     } catch (std::exception& e) {
20738       {
20739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20740       };
20741     } catch (Dali::DaliException e) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20744       };
20745     } catch (...) {
20746       {
20747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20748       };
20749     }
20750   }
20751
20752 }
20753
20754
20755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20756   int jresult ;
20757   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20758   std::string *arg2 = 0 ;
20759   Dali::Property::Value *arg3 = 0 ;
20760   Dali::Property::Index result;
20761
20762   arg1 = (Dali::Handle *)jarg1;
20763   if (!jarg2) {
20764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20765     return 0;
20766   }
20767   std::string arg2_str(jarg2);
20768   arg2 = &arg2_str;
20769   arg3 = (Dali::Property::Value *)jarg3;
20770   if (!arg3) {
20771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20772     return 0;
20773   }
20774   {
20775     try {
20776       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20777     } catch (std::out_of_range& e) {
20778       {
20779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20780       };
20781     } catch (std::exception& e) {
20782       {
20783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20784       };
20785     } catch (Dali::DaliException e) {
20786       {
20787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20788       };
20789     } catch (...) {
20790       {
20791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20792       };
20793     }
20794   }
20795
20796   jresult = result;
20797
20798   //argout typemap for const std::string&
20799
20800   return jresult;
20801 }
20802
20803
20804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20805   int jresult ;
20806   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20807   std::string *arg2 = 0 ;
20808   Dali::Property::Value *arg3 = 0 ;
20809   Dali::Property::AccessMode arg4 ;
20810   Dali::Property::Index result;
20811
20812   arg1 = (Dali::Handle *)jarg1;
20813   if (!jarg2) {
20814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20815     return 0;
20816   }
20817   std::string arg2_str(jarg2);
20818   arg2 = &arg2_str;
20819   arg3 = (Dali::Property::Value *)jarg3;
20820   if (!arg3) {
20821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20822     return 0;
20823   }
20824   arg4 = (Dali::Property::AccessMode)jarg4;
20825   {
20826     try {
20827       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20828     } catch (std::out_of_range& e) {
20829       {
20830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20831       };
20832     } catch (std::exception& e) {
20833       {
20834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20835       };
20836     } catch (Dali::DaliException e) {
20837       {
20838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20839       };
20840     } catch (...) {
20841       {
20842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20843       };
20844     }
20845   }
20846
20847   jresult = result;
20848
20849   //argout typemap for const std::string&
20850
20851   return jresult;
20852 }
20853
20854
20855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20856   void * jresult ;
20857   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20858   Dali::Property::Index arg2 ;
20859   Dali::Property::Value result;
20860
20861   arg1 = (Dali::Handle *)jarg1;
20862   arg2 = (Dali::Property::Index)jarg2;
20863   {
20864     try {
20865       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20866     } catch (std::out_of_range& e) {
20867       {
20868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (std::exception& e) {
20871       {
20872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20873       };
20874     } catch (Dali::DaliException e) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20877       };
20878     } catch (...) {
20879       {
20880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20881       };
20882     }
20883   }
20884
20885   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20886   return jresult;
20887 }
20888
20889
20890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20891   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20892   Dali::Property::IndexContainer *arg2 = 0 ;
20893
20894   arg1 = (Dali::Handle *)jarg1;
20895   arg2 = (Dali::Property::IndexContainer *)jarg2;
20896   if (!arg2) {
20897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20898     return ;
20899   }
20900   {
20901     try {
20902       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20903     } catch (std::out_of_range& e) {
20904       {
20905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20906       };
20907     } catch (std::exception& e) {
20908       {
20909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20910       };
20911     } catch (Dali::DaliException e) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20914       };
20915     } catch (...) {
20916       {
20917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20918       };
20919     }
20920   }
20921
20922 }
20923
20924
20925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20926   void * jresult ;
20927   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20928   Dali::Property::Index arg2 ;
20929   Dali::PropertyCondition *arg3 = 0 ;
20930   Dali::PropertyNotification result;
20931
20932   arg1 = (Dali::Handle *)jarg1;
20933   arg2 = (Dali::Property::Index)jarg2;
20934   arg3 = (Dali::PropertyCondition *)jarg3;
20935   if (!arg3) {
20936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20937     return 0;
20938   }
20939   {
20940     try {
20941       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20942     } catch (std::out_of_range& e) {
20943       {
20944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20945       };
20946     } catch (std::exception& e) {
20947       {
20948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20949       };
20950     } catch (Dali::DaliException e) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20953       };
20954     } catch (...) {
20955       {
20956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20957       };
20958     }
20959   }
20960
20961   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20962   return jresult;
20963 }
20964
20965
20966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20967   void * jresult ;
20968   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20969   Dali::Property::Index arg2 ;
20970   int arg3 ;
20971   Dali::PropertyCondition *arg4 = 0 ;
20972   Dali::PropertyNotification result;
20973
20974   arg1 = (Dali::Handle *)jarg1;
20975   arg2 = (Dali::Property::Index)jarg2;
20976   arg3 = (int)jarg3;
20977   arg4 = (Dali::PropertyCondition *)jarg4;
20978   if (!arg4) {
20979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20980     return 0;
20981   }
20982   {
20983     try {
20984       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20985     } catch (std::out_of_range& e) {
20986       {
20987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20988       };
20989     } catch (std::exception& e) {
20990       {
20991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20992       };
20993     } catch (Dali::DaliException e) {
20994       {
20995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20996       };
20997     } catch (...) {
20998       {
20999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21000       };
21001     }
21002   }
21003
21004   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21005   return jresult;
21006 }
21007
21008
21009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21010   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21011   Dali::PropertyNotification arg2 ;
21012   Dali::PropertyNotification *argp2 ;
21013
21014   arg1 = (Dali::Handle *)jarg1;
21015   argp2 = (Dali::PropertyNotification *)jarg2;
21016   if (!argp2) {
21017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21018     return ;
21019   }
21020   arg2 = *argp2;
21021   {
21022     try {
21023       (arg1)->RemovePropertyNotification(arg2);
21024     } catch (std::out_of_range& e) {
21025       {
21026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (std::exception& e) {
21029       {
21030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21031       };
21032     } catch (Dali::DaliException e) {
21033       {
21034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21035       };
21036     } catch (...) {
21037       {
21038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21039       };
21040     }
21041   }
21042
21043 }
21044
21045
21046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21047   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21048
21049   arg1 = (Dali::Handle *)jarg1;
21050   {
21051     try {
21052       (arg1)->RemovePropertyNotifications();
21053     } catch (std::out_of_range& e) {
21054       {
21055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21056       };
21057     } catch (std::exception& e) {
21058       {
21059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21060       };
21061     } catch (Dali::DaliException e) {
21062       {
21063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21068       };
21069     }
21070   }
21071
21072 }
21073
21074
21075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21077
21078   arg1 = (Dali::Handle *)jarg1;
21079   {
21080     try {
21081       (arg1)->RemoveConstraints();
21082     } catch (std::out_of_range& e) {
21083       {
21084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21085       };
21086     } catch (std::exception& e) {
21087       {
21088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21089       };
21090     } catch (Dali::DaliException e) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21093       };
21094     } catch (...) {
21095       {
21096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21097       };
21098     }
21099   }
21100
21101 }
21102
21103
21104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21105   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21106   unsigned int arg2 ;
21107
21108   arg1 = (Dali::Handle *)jarg1;
21109   arg2 = (unsigned int)jarg2;
21110   {
21111     try {
21112       (arg1)->RemoveConstraints(arg2);
21113     } catch (std::out_of_range& e) {
21114       {
21115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (std::exception& e) {
21118       {
21119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21120       };
21121     } catch (Dali::DaliException e) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21124       };
21125     } catch (...) {
21126       {
21127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21128       };
21129     }
21130   }
21131
21132 }
21133
21134
21135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21136   int jresult ;
21137   Dali::Property::Index result;
21138
21139   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21140   jresult = result;
21141   return jresult;
21142 }
21143
21144
21145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21146   void * jresult ;
21147   Dali::Handle result;
21148
21149   {
21150     try {
21151       result = Dali::WeightObject::New();
21152     } catch (std::out_of_range& e) {
21153       {
21154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (std::exception& e) {
21157       {
21158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21159       };
21160     } catch (Dali::DaliException e) {
21161       {
21162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21163       };
21164     } catch (...) {
21165       {
21166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21167       };
21168     }
21169   }
21170
21171   jresult = new Dali::Handle((const Dali::Handle &)result);
21172   return jresult;
21173 }
21174
21175
21176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21177   void * jresult ;
21178   Dali::TypeInfo *result = 0 ;
21179
21180   {
21181     try {
21182       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21183     } catch (std::out_of_range& e) {
21184       {
21185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21186       };
21187     } catch (std::exception& e) {
21188       {
21189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21190       };
21191     } catch (Dali::DaliException e) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21194       };
21195     } catch (...) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21198       };
21199     }
21200   }
21201
21202   jresult = (void *)result;
21203   return jresult;
21204 }
21205
21206
21207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21208   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21209
21210   arg1 = (Dali::TypeInfo *)jarg1;
21211   {
21212     try {
21213       delete arg1;
21214     } catch (std::out_of_range& e) {
21215       {
21216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21217       };
21218     } catch (std::exception& e) {
21219       {
21220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21221       };
21222     } catch (Dali::DaliException e) {
21223       {
21224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21225       };
21226     } catch (...) {
21227       {
21228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21229       };
21230     }
21231   }
21232
21233 }
21234
21235
21236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21237   void * jresult ;
21238   Dali::TypeInfo *arg1 = 0 ;
21239   Dali::TypeInfo *result = 0 ;
21240
21241   arg1 = (Dali::TypeInfo *)jarg1;
21242   if (!arg1) {
21243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21244     return 0;
21245   }
21246   {
21247     try {
21248       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21249     } catch (std::out_of_range& e) {
21250       {
21251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (std::exception& e) {
21254       {
21255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21256       };
21257     } catch (Dali::DaliException e) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21260       };
21261     } catch (...) {
21262       {
21263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21264       };
21265     }
21266   }
21267
21268   jresult = (void *)result;
21269   return jresult;
21270 }
21271
21272
21273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21274   void * jresult ;
21275   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21276   Dali::TypeInfo *arg2 = 0 ;
21277   Dali::TypeInfo *result = 0 ;
21278
21279   arg1 = (Dali::TypeInfo *)jarg1;
21280   arg2 = (Dali::TypeInfo *)jarg2;
21281   if (!arg2) {
21282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21283     return 0;
21284   }
21285   {
21286     try {
21287       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21288     } catch (std::out_of_range& e) {
21289       {
21290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21291       };
21292     } catch (std::exception& e) {
21293       {
21294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21295       };
21296     } catch (Dali::DaliException e) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21299       };
21300     } catch (...) {
21301       {
21302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21303       };
21304     }
21305   }
21306
21307   jresult = (void *)result;
21308   return jresult;
21309 }
21310
21311
21312 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21313   char * jresult ;
21314   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21315   std::string *result = 0 ;
21316
21317   arg1 = (Dali::TypeInfo *)jarg1;
21318   {
21319     try {
21320       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21321     } catch (std::out_of_range& e) {
21322       {
21323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (std::exception& e) {
21326       {
21327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21328       };
21329     } catch (Dali::DaliException e) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21332       };
21333     } catch (...) {
21334       {
21335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21336       };
21337     }
21338   }
21339
21340   jresult = SWIG_csharp_string_callback(result->c_str());
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21346   char * jresult ;
21347   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21348   std::string *result = 0 ;
21349
21350   arg1 = (Dali::TypeInfo *)jarg1;
21351   {
21352     try {
21353       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21354     } catch (std::out_of_range& e) {
21355       {
21356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (std::exception& e) {
21359       {
21360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21361       };
21362     } catch (Dali::DaliException e) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21365       };
21366     } catch (...) {
21367       {
21368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21369       };
21370     }
21371   }
21372
21373   jresult = SWIG_csharp_string_callback(result->c_str());
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21379   void * jresult ;
21380   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21381   Dali::BaseHandle result;
21382
21383   arg1 = (Dali::TypeInfo *)jarg1;
21384   {
21385     try {
21386       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21387     } catch (std::out_of_range& e) {
21388       {
21389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (std::exception& e) {
21392       {
21393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21394       };
21395     } catch (Dali::DaliException e) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21398       };
21399     } catch (...) {
21400       {
21401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21402       };
21403     }
21404   }
21405
21406   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21407   return jresult;
21408 }
21409
21410
21411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21412   unsigned long jresult ;
21413   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21414   size_t result;
21415
21416   arg1 = (Dali::TypeInfo *)jarg1;
21417   {
21418     try {
21419       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21420     } catch (std::out_of_range& e) {
21421       {
21422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21423       };
21424     } catch (std::exception& e) {
21425       {
21426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21427       };
21428     } catch (Dali::DaliException e) {
21429       {
21430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21431       };
21432     } catch (...) {
21433       {
21434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21435       };
21436     }
21437   }
21438
21439   jresult = (unsigned long)result;
21440   return jresult;
21441 }
21442
21443
21444 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21445   char * jresult ;
21446   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21447   size_t arg2 ;
21448   std::string result;
21449
21450   arg1 = (Dali::TypeInfo *)jarg1;
21451   arg2 = (size_t)jarg2;
21452   {
21453     try {
21454       result = (arg1)->GetActionName(arg2);
21455     } catch (std::out_of_range& e) {
21456       {
21457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (std::exception& e) {
21460       {
21461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21462       };
21463     } catch (Dali::DaliException e) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21466       };
21467     } catch (...) {
21468       {
21469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21470       };
21471     }
21472   }
21473
21474   jresult = SWIG_csharp_string_callback((&result)->c_str());
21475   return jresult;
21476 }
21477
21478
21479 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21480   unsigned long jresult ;
21481   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21482   size_t result;
21483
21484   arg1 = (Dali::TypeInfo *)jarg1;
21485   {
21486     try {
21487       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (Dali::DaliException e) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21499       };
21500     } catch (...) {
21501       {
21502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21503       };
21504     }
21505   }
21506
21507   jresult = (unsigned long)result;
21508   return jresult;
21509 }
21510
21511
21512 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21513   char * jresult ;
21514   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21515   size_t arg2 ;
21516   std::string result;
21517
21518   arg1 = (Dali::TypeInfo *)jarg1;
21519   arg2 = (size_t)jarg2;
21520   {
21521     try {
21522       result = (arg1)->GetSignalName(arg2);
21523     } catch (std::out_of_range& e) {
21524       {
21525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (std::exception& e) {
21528       {
21529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21530       };
21531     } catch (Dali::DaliException e) {
21532       {
21533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21534       };
21535     } catch (...) {
21536       {
21537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21538       };
21539     }
21540   }
21541
21542   jresult = SWIG_csharp_string_callback((&result)->c_str());
21543   return jresult;
21544 }
21545
21546
21547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21548   unsigned long jresult ;
21549   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21550   size_t result;
21551
21552   arg1 = (Dali::TypeInfo *)jarg1;
21553   {
21554     try {
21555       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21556     } catch (std::out_of_range& e) {
21557       {
21558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (std::exception& e) {
21561       {
21562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21563       };
21564     } catch (Dali::DaliException e) {
21565       {
21566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21567       };
21568     } catch (...) {
21569       {
21570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21571       };
21572     }
21573   }
21574
21575   jresult = (unsigned long)result;
21576   return jresult;
21577 }
21578
21579
21580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21581   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21582   Dali::Property::IndexContainer *arg2 = 0 ;
21583
21584   arg1 = (Dali::TypeInfo *)jarg1;
21585   arg2 = (Dali::Property::IndexContainer *)jarg2;
21586   if (!arg2) {
21587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21588     return ;
21589   }
21590   {
21591     try {
21592       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21593     } catch (std::out_of_range& e) {
21594       {
21595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21596       };
21597     } catch (std::exception& e) {
21598       {
21599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21600       };
21601     } catch (Dali::DaliException e) {
21602       {
21603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21604       };
21605     } catch (...) {
21606       {
21607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21608       };
21609     }
21610   }
21611
21612 }
21613
21614
21615 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21616   char * jresult ;
21617   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21618   Dali::Property::Index arg2 ;
21619   std::string *result = 0 ;
21620
21621   arg1 = (Dali::TypeInfo *)jarg1;
21622   arg2 = (Dali::Property::Index)jarg2;
21623   {
21624     try {
21625       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21626     } catch (std::out_of_range& e) {
21627       {
21628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21629       };
21630     } catch (std::exception& e) {
21631       {
21632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21633       };
21634     } catch (Dali::DaliException e) {
21635       {
21636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21637       };
21638     } catch (...) {
21639       {
21640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21641       };
21642     }
21643   }
21644
21645   jresult = SWIG_csharp_string_callback(result->c_str());
21646   return jresult;
21647 }
21648
21649
21650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21651   void * jresult ;
21652   Dali::TypeRegistry result;
21653
21654   {
21655     try {
21656       result = Dali::TypeRegistry::Get();
21657     } catch (std::out_of_range& e) {
21658       {
21659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21660       };
21661     } catch (std::exception& e) {
21662       {
21663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21664       };
21665     } catch (Dali::DaliException e) {
21666       {
21667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21668       };
21669     } catch (...) {
21670       {
21671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21672       };
21673     }
21674   }
21675
21676   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21677   return jresult;
21678 }
21679
21680
21681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21682   void * jresult ;
21683   Dali::TypeRegistry *result = 0 ;
21684
21685   {
21686     try {
21687       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21688     } catch (std::out_of_range& e) {
21689       {
21690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (std::exception& e) {
21693       {
21694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21695       };
21696     } catch (Dali::DaliException e) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21699       };
21700     } catch (...) {
21701       {
21702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21703       };
21704     }
21705   }
21706
21707   jresult = (void *)result;
21708   return jresult;
21709 }
21710
21711
21712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21713   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21714
21715   arg1 = (Dali::TypeRegistry *)jarg1;
21716   {
21717     try {
21718       delete arg1;
21719     } catch (std::out_of_range& e) {
21720       {
21721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21722       };
21723     } catch (std::exception& e) {
21724       {
21725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21726       };
21727     } catch (Dali::DaliException e) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21730       };
21731     } catch (...) {
21732       {
21733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21734       };
21735     }
21736   }
21737
21738 }
21739
21740
21741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21742   void * jresult ;
21743   Dali::TypeRegistry *arg1 = 0 ;
21744   Dali::TypeRegistry *result = 0 ;
21745
21746   arg1 = (Dali::TypeRegistry *)jarg1;
21747   if (!arg1) {
21748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21749     return 0;
21750   }
21751   {
21752     try {
21753       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21754     } catch (std::out_of_range& e) {
21755       {
21756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21757       };
21758     } catch (std::exception& e) {
21759       {
21760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21761       };
21762     } catch (Dali::DaliException e) {
21763       {
21764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21765       };
21766     } catch (...) {
21767       {
21768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21769       };
21770     }
21771   }
21772
21773   jresult = (void *)result;
21774   return jresult;
21775 }
21776
21777
21778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21779   void * jresult ;
21780   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21781   Dali::TypeRegistry *arg2 = 0 ;
21782   Dali::TypeRegistry *result = 0 ;
21783
21784   arg1 = (Dali::TypeRegistry *)jarg1;
21785   arg2 = (Dali::TypeRegistry *)jarg2;
21786   if (!arg2) {
21787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21788     return 0;
21789   }
21790   {
21791     try {
21792       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21793     } catch (std::out_of_range& e) {
21794       {
21795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21796       };
21797     } catch (std::exception& e) {
21798       {
21799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21800       };
21801     } catch (Dali::DaliException e) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21808       };
21809     }
21810   }
21811
21812   jresult = (void *)result;
21813   return jresult;
21814 }
21815
21816
21817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21818   void * jresult ;
21819   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21820   std::string *arg2 = 0 ;
21821   Dali::TypeInfo result;
21822
21823   arg1 = (Dali::TypeRegistry *)jarg1;
21824   if (!jarg2) {
21825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21826     return 0;
21827   }
21828   std::string arg2_str(jarg2);
21829   arg2 = &arg2_str;
21830   {
21831     try {
21832       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21833     } catch (std::out_of_range& e) {
21834       {
21835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (std::exception& e) {
21838       {
21839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21840       };
21841     } catch (Dali::DaliException e) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21844       };
21845     } catch (...) {
21846       {
21847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21848       };
21849     }
21850   }
21851
21852   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21853
21854   //argout typemap for const std::string&
21855
21856   return jresult;
21857 }
21858
21859
21860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21861   void * jresult ;
21862   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21863   std::type_info *arg2 = 0 ;
21864   Dali::TypeInfo result;
21865
21866   arg1 = (Dali::TypeRegistry *)jarg1;
21867   arg2 = (std::type_info *)jarg2;
21868   if (!arg2) {
21869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21870     return 0;
21871   }
21872   {
21873     try {
21874       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21875     } catch (std::out_of_range& e) {
21876       {
21877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21878       };
21879     } catch (std::exception& e) {
21880       {
21881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21882       };
21883     } catch (Dali::DaliException e) {
21884       {
21885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21890       };
21891     }
21892   }
21893
21894   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21895   return jresult;
21896 }
21897
21898
21899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21900   unsigned long jresult ;
21901   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21902   size_t result;
21903
21904   arg1 = (Dali::TypeRegistry *)jarg1;
21905   {
21906     try {
21907       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21908     } catch (std::out_of_range& e) {
21909       {
21910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (std::exception& e) {
21913       {
21914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21915       };
21916     } catch (Dali::DaliException e) {
21917       {
21918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21919       };
21920     } catch (...) {
21921       {
21922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21923       };
21924     }
21925   }
21926
21927   jresult = (unsigned long)result;
21928   return jresult;
21929 }
21930
21931
21932 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21933   char * jresult ;
21934   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21935   size_t arg2 ;
21936   std::string result;
21937
21938   arg1 = (Dali::TypeRegistry *)jarg1;
21939   arg2 = (size_t)jarg2;
21940   {
21941     try {
21942       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21943     } catch (std::out_of_range& e) {
21944       {
21945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21946       };
21947     } catch (std::exception& e) {
21948       {
21949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21950       };
21951     } catch (Dali::DaliException e) {
21952       {
21953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21954       };
21955     } catch (...) {
21956       {
21957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21958       };
21959     }
21960   }
21961
21962   jresult = SWIG_csharp_string_callback((&result)->c_str());
21963   return jresult;
21964 }
21965
21966
21967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21968   void * jresult ;
21969   std::type_info *arg1 = 0 ;
21970   std::type_info *arg2 = 0 ;
21971   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21972   Dali::TypeRegistration *result = 0 ;
21973
21974   arg1 = (std::type_info *)jarg1;
21975   if (!arg1) {
21976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21977     return 0;
21978   }
21979   arg2 = (std::type_info *)jarg2;
21980   if (!arg2) {
21981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21982     return 0;
21983   }
21984   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21985   {
21986     try {
21987       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21988     } catch (std::out_of_range& e) {
21989       {
21990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21991       };
21992     } catch (std::exception& e) {
21993       {
21994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21995       };
21996     } catch (Dali::DaliException e) {
21997       {
21998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21999       };
22000     } catch (...) {
22001       {
22002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22003       };
22004     }
22005   }
22006
22007   jresult = (void *)result;
22008   return jresult;
22009 }
22010
22011
22012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22013   void * jresult ;
22014   std::type_info *arg1 = 0 ;
22015   std::type_info *arg2 = 0 ;
22016   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22017   bool arg4 ;
22018   Dali::TypeRegistration *result = 0 ;
22019
22020   arg1 = (std::type_info *)jarg1;
22021   if (!arg1) {
22022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22023     return 0;
22024   }
22025   arg2 = (std::type_info *)jarg2;
22026   if (!arg2) {
22027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22028     return 0;
22029   }
22030   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22031   arg4 = jarg4 ? true : false;
22032   {
22033     try {
22034       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22035     } catch (std::out_of_range& e) {
22036       {
22037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22038       };
22039     } catch (std::exception& e) {
22040       {
22041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22042       };
22043     } catch (Dali::DaliException e) {
22044       {
22045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22046       };
22047     } catch (...) {
22048       {
22049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22050       };
22051     }
22052   }
22053
22054   jresult = (void *)result;
22055   return jresult;
22056 }
22057
22058
22059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22060   void * jresult ;
22061   std::string *arg1 = 0 ;
22062   std::type_info *arg2 = 0 ;
22063   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22064   Dali::TypeRegistration *result = 0 ;
22065
22066   if (!jarg1) {
22067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22068     return 0;
22069   }
22070   std::string arg1_str(jarg1);
22071   arg1 = &arg1_str;
22072   arg2 = (std::type_info *)jarg2;
22073   if (!arg2) {
22074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22075     return 0;
22076   }
22077   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22078   {
22079     try {
22080       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22081     } catch (std::out_of_range& e) {
22082       {
22083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22084       };
22085     } catch (std::exception& e) {
22086       {
22087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22088       };
22089     } catch (Dali::DaliException e) {
22090       {
22091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22092       };
22093     } catch (...) {
22094       {
22095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22096       };
22097     }
22098   }
22099
22100   jresult = (void *)result;
22101
22102   //argout typemap for const std::string&
22103
22104   return jresult;
22105 }
22106
22107
22108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22109   char * jresult ;
22110   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22111   std::string result;
22112
22113   arg1 = (Dali::TypeRegistration *)jarg1;
22114   {
22115     try {
22116       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (Dali::DaliException e) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135
22136   jresult = SWIG_csharp_string_callback((&result)->c_str());
22137   return jresult;
22138 }
22139
22140
22141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22142   std::string *arg1 = 0 ;
22143   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22144
22145   if (!jarg1) {
22146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22147     return ;
22148   }
22149   std::string arg1_str(jarg1);
22150   arg1 = &arg1_str;
22151   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22152   {
22153     try {
22154       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22155     } catch (std::out_of_range& e) {
22156       {
22157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22158       };
22159     } catch (std::exception& e) {
22160       {
22161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22162       };
22163     } catch (Dali::DaliException e) {
22164       {
22165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22166       };
22167     } catch (...) {
22168       {
22169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22170       };
22171     }
22172   }
22173
22174
22175   //argout typemap for const std::string&
22176
22177 }
22178
22179
22180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22181   std::string *arg1 = 0 ;
22182   std::string *arg2 = 0 ;
22183   int arg3 ;
22184   Dali::Property::Type arg4 ;
22185   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22186   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22187
22188   if (!jarg1) {
22189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22190     return ;
22191   }
22192   std::string arg1_str(jarg1);
22193   arg1 = &arg1_str;
22194   if (!jarg2) {
22195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22196     return ;
22197   }
22198   std::string arg2_str(jarg2);
22199   arg2 = &arg2_str;
22200   arg3 = (int)jarg3;
22201   arg4 = (Dali::Property::Type)jarg4;
22202   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22203   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22204   {
22205     try {
22206       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22207     } catch (std::out_of_range& e) {
22208       {
22209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22210       };
22211     } catch (std::exception& e) {
22212       {
22213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22214       };
22215     } catch (Dali::DaliException e) {
22216       {
22217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22218       };
22219     } catch (...) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22222       };
22223     }
22224   }
22225
22226
22227   //argout typemap for const std::string&
22228
22229
22230   //argout typemap for const std::string&
22231
22232 }
22233
22234
22235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22236   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22237
22238   arg1 = (Dali::TypeRegistration *)jarg1;
22239   {
22240     try {
22241       delete arg1;
22242     } catch (std::out_of_range& e) {
22243       {
22244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22245       };
22246     } catch (std::exception& e) {
22247       {
22248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22249       };
22250     } catch (Dali::DaliException e) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22253       };
22254     } catch (...) {
22255       {
22256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22257       };
22258     }
22259   }
22260
22261 }
22262
22263
22264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22265   void * jresult ;
22266   Dali::TypeRegistration *arg1 = 0 ;
22267   std::string *arg2 = 0 ;
22268   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22269   Dali::SignalConnectorType *result = 0 ;
22270
22271   arg1 = (Dali::TypeRegistration *)jarg1;
22272   if (!arg1) {
22273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22274     return 0;
22275   }
22276   if (!jarg2) {
22277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22278     return 0;
22279   }
22280   std::string arg2_str(jarg2);
22281   arg2 = &arg2_str;
22282   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22283   {
22284     try {
22285       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22286     } catch (std::out_of_range& e) {
22287       {
22288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22289       };
22290     } catch (std::exception& e) {
22291       {
22292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22293       };
22294     } catch (Dali::DaliException e) {
22295       {
22296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22297       };
22298     } catch (...) {
22299       {
22300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22301       };
22302     }
22303   }
22304
22305   jresult = (void *)result;
22306
22307   //argout typemap for const std::string&
22308
22309   return jresult;
22310 }
22311
22312
22313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22314   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22315
22316   arg1 = (Dali::SignalConnectorType *)jarg1;
22317   {
22318     try {
22319       delete arg1;
22320     } catch (std::out_of_range& e) {
22321       {
22322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22323       };
22324     } catch (std::exception& e) {
22325       {
22326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22327       };
22328     } catch (Dali::DaliException e) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22331       };
22332     } catch (...) {
22333       {
22334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22335       };
22336     }
22337   }
22338
22339 }
22340
22341
22342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22343   void * jresult ;
22344   Dali::TypeRegistration *arg1 = 0 ;
22345   std::string *arg2 = 0 ;
22346   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22347   Dali::TypeAction *result = 0 ;
22348
22349   arg1 = (Dali::TypeRegistration *)jarg1;
22350   if (!arg1) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22352     return 0;
22353   }
22354   if (!jarg2) {
22355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22356     return 0;
22357   }
22358   std::string arg2_str(jarg2);
22359   arg2 = &arg2_str;
22360   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22361   {
22362     try {
22363       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22364     } catch (std::out_of_range& e) {
22365       {
22366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22367       };
22368     } catch (std::exception& e) {
22369       {
22370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22371       };
22372     } catch (Dali::DaliException e) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22375       };
22376     } catch (...) {
22377       {
22378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22379       };
22380     }
22381   }
22382
22383   jresult = (void *)result;
22384
22385   //argout typemap for const std::string&
22386
22387   return jresult;
22388 }
22389
22390
22391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22392   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22393
22394   arg1 = (Dali::TypeAction *)jarg1;
22395   {
22396     try {
22397       delete arg1;
22398     } catch (std::out_of_range& e) {
22399       {
22400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22401       };
22402     } catch (std::exception& e) {
22403       {
22404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22405       };
22406     } catch (Dali::DaliException e) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22409       };
22410     } catch (...) {
22411       {
22412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22413       };
22414     }
22415   }
22416
22417 }
22418
22419
22420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22421   void * jresult ;
22422   Dali::TypeRegistration *arg1 = 0 ;
22423   std::string *arg2 = 0 ;
22424   Dali::Property::Index arg3 ;
22425   Dali::Property::Type arg4 ;
22426   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22427   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22428   Dali::PropertyRegistration *result = 0 ;
22429
22430   arg1 = (Dali::TypeRegistration *)jarg1;
22431   if (!arg1) {
22432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22433     return 0;
22434   }
22435   if (!jarg2) {
22436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22437     return 0;
22438   }
22439   std::string arg2_str(jarg2);
22440   arg2 = &arg2_str;
22441   arg3 = (Dali::Property::Index)jarg3;
22442   arg4 = (Dali::Property::Type)jarg4;
22443   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22444   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22445   {
22446     try {
22447       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22448     } catch (std::out_of_range& e) {
22449       {
22450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22451       };
22452     } catch (std::exception& e) {
22453       {
22454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (Dali::DaliException e) {
22457       {
22458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22459       };
22460     } catch (...) {
22461       {
22462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22463       };
22464     }
22465   }
22466
22467   jresult = (void *)result;
22468
22469   //argout typemap for const std::string&
22470
22471   return jresult;
22472 }
22473
22474
22475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22476   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22477
22478   arg1 = (Dali::PropertyRegistration *)jarg1;
22479   {
22480     try {
22481       delete arg1;
22482     } catch (std::out_of_range& e) {
22483       {
22484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22485       };
22486     } catch (std::exception& e) {
22487       {
22488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22489       };
22490     } catch (Dali::DaliException e) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22493       };
22494     } catch (...) {
22495       {
22496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22497       };
22498     }
22499   }
22500
22501 }
22502
22503
22504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22505   void * jresult ;
22506   Dali::TypeRegistration *arg1 = 0 ;
22507   std::string *arg2 = 0 ;
22508   Dali::Property::Index arg3 ;
22509   Dali::Property::Type arg4 ;
22510   Dali::AnimatablePropertyRegistration *result = 0 ;
22511
22512   arg1 = (Dali::TypeRegistration *)jarg1;
22513   if (!arg1) {
22514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22515     return 0;
22516   }
22517   if (!jarg2) {
22518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22519     return 0;
22520   }
22521   std::string arg2_str(jarg2);
22522   arg2 = &arg2_str;
22523   arg3 = (Dali::Property::Index)jarg3;
22524   arg4 = (Dali::Property::Type)jarg4;
22525   {
22526     try {
22527       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22528     } catch (std::out_of_range& e) {
22529       {
22530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22531       };
22532     } catch (std::exception& e) {
22533       {
22534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22535       };
22536     } catch (Dali::DaliException e) {
22537       {
22538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22539       };
22540     } catch (...) {
22541       {
22542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22543       };
22544     }
22545   }
22546
22547   jresult = (void *)result;
22548
22549   //argout typemap for const std::string&
22550
22551   return jresult;
22552 }
22553
22554
22555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22556   void * jresult ;
22557   Dali::TypeRegistration *arg1 = 0 ;
22558   std::string *arg2 = 0 ;
22559   Dali::Property::Index arg3 ;
22560   Dali::Property::Value *arg4 = 0 ;
22561   Dali::AnimatablePropertyRegistration *result = 0 ;
22562
22563   arg1 = (Dali::TypeRegistration *)jarg1;
22564   if (!arg1) {
22565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22566     return 0;
22567   }
22568   if (!jarg2) {
22569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22570     return 0;
22571   }
22572   std::string arg2_str(jarg2);
22573   arg2 = &arg2_str;
22574   arg3 = (Dali::Property::Index)jarg3;
22575   arg4 = (Dali::Property::Value *)jarg4;
22576   if (!arg4) {
22577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22578     return 0;
22579   }
22580   {
22581     try {
22582       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22583     } catch (std::out_of_range& e) {
22584       {
22585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (std::exception& e) {
22588       {
22589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22590       };
22591     } catch (Dali::DaliException e) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22594       };
22595     } catch (...) {
22596       {
22597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22598       };
22599     }
22600   }
22601
22602   jresult = (void *)result;
22603
22604   //argout typemap for const std::string&
22605
22606   return jresult;
22607 }
22608
22609
22610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22611   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22612
22613   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22614   {
22615     try {
22616       delete arg1;
22617     } catch (std::out_of_range& e) {
22618       {
22619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22620       };
22621     } catch (std::exception& e) {
22622       {
22623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22624       };
22625     } catch (Dali::DaliException e) {
22626       {
22627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22628       };
22629     } catch (...) {
22630       {
22631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22632       };
22633     }
22634   }
22635
22636 }
22637
22638
22639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22640   void * jresult ;
22641   Dali::TypeRegistration *arg1 = 0 ;
22642   std::string *arg2 = 0 ;
22643   Dali::Property::Index arg3 ;
22644   Dali::Property::Index arg4 ;
22645   unsigned int arg5 ;
22646   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22647
22648   arg1 = (Dali::TypeRegistration *)jarg1;
22649   if (!arg1) {
22650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22651     return 0;
22652   }
22653   if (!jarg2) {
22654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22655     return 0;
22656   }
22657   std::string arg2_str(jarg2);
22658   arg2 = &arg2_str;
22659   arg3 = (Dali::Property::Index)jarg3;
22660   arg4 = (Dali::Property::Index)jarg4;
22661   arg5 = (unsigned int)jarg5;
22662   {
22663     try {
22664       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22665     } catch (std::out_of_range& e) {
22666       {
22667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (std::exception& e) {
22670       {
22671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22672       };
22673     } catch (Dali::DaliException e) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22676       };
22677     } catch (...) {
22678       {
22679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22680       };
22681     }
22682   }
22683
22684   jresult = (void *)result;
22685
22686   //argout typemap for const std::string&
22687
22688   return jresult;
22689 }
22690
22691
22692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22693   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22694
22695   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22696   {
22697     try {
22698       delete arg1;
22699     } catch (std::out_of_range& e) {
22700       {
22701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22702       };
22703     } catch (std::exception& e) {
22704       {
22705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22706       };
22707     } catch (Dali::DaliException e) {
22708       {
22709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22710       };
22711     } catch (...) {
22712       {
22713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22714       };
22715     }
22716   }
22717
22718 }
22719
22720
22721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22722   void * jresult ;
22723   Dali::TypeRegistration *arg1 = 0 ;
22724   std::string *arg2 = 0 ;
22725   Dali::Property::Index arg3 ;
22726   Dali::Property::Type arg4 ;
22727   Dali::ChildPropertyRegistration *result = 0 ;
22728
22729   arg1 = (Dali::TypeRegistration *)jarg1;
22730   if (!arg1) {
22731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22732     return 0;
22733   }
22734   if (!jarg2) {
22735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22736     return 0;
22737   }
22738   std::string arg2_str(jarg2);
22739   arg2 = &arg2_str;
22740   arg3 = (Dali::Property::Index)jarg3;
22741   arg4 = (Dali::Property::Type)jarg4;
22742   {
22743     try {
22744       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22745     } catch (std::out_of_range& e) {
22746       {
22747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22748       };
22749     } catch (std::exception& e) {
22750       {
22751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22752       };
22753     } catch (Dali::DaliException e) {
22754       {
22755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22756       };
22757     } catch (...) {
22758       {
22759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22760       };
22761     }
22762   }
22763
22764   jresult = (void *)result;
22765
22766   //argout typemap for const std::string&
22767
22768   return jresult;
22769 }
22770
22771
22772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22773   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22774
22775   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22776   {
22777     try {
22778       delete arg1;
22779     } catch (std::out_of_range& e) {
22780       {
22781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22782       };
22783     } catch (std::exception& e) {
22784       {
22785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22786       };
22787     } catch (Dali::DaliException e) {
22788       {
22789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22790       };
22791     } catch (...) {
22792       {
22793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22794       };
22795     }
22796   }
22797
22798 }
22799
22800
22801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22802   unsigned int jresult ;
22803   std::string *arg1 = 0 ;
22804   std::type_info *arg2 = 0 ;
22805   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22806   bool result;
22807
22808   if (!jarg1) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22810     return 0;
22811   }
22812   std::string arg1_str(jarg1);
22813   arg1 = &arg1_str;
22814   arg2 = (std::type_info *)jarg2;
22815   if (!arg2) {
22816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22817     return 0;
22818   }
22819   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22820   {
22821     try {
22822       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22823     } catch (std::out_of_range& e) {
22824       {
22825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22826       };
22827     } catch (std::exception& e) {
22828       {
22829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22830       };
22831     } catch (Dali::DaliException e) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22834       };
22835     } catch (...) {
22836       {
22837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22838       };
22839     }
22840   }
22841
22842   jresult = result;
22843
22844   //argout typemap for const std::string&
22845
22846   return jresult;
22847 }
22848
22849
22850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22851   unsigned int jresult ;
22852   std::string *arg1 = 0 ;
22853   std::string *arg2 = 0 ;
22854   Dali::Property::Index arg3 ;
22855   Dali::Property::Type arg4 ;
22856   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22857   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22858   bool result;
22859
22860   if (!jarg1) {
22861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22862     return 0;
22863   }
22864   std::string arg1_str(jarg1);
22865   arg1 = &arg1_str;
22866   if (!jarg2) {
22867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22868     return 0;
22869   }
22870   std::string arg2_str(jarg2);
22871   arg2 = &arg2_str;
22872   arg3 = (Dali::Property::Index)jarg3;
22873   arg4 = (Dali::Property::Type)jarg4;
22874   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22875   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22876   {
22877     try {
22878       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22879     } catch (std::out_of_range& e) {
22880       {
22881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22882       };
22883     } catch (std::exception& e) {
22884       {
22885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22886       };
22887     } catch (Dali::DaliException e) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22890       };
22891     } catch (...) {
22892       {
22893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22894       };
22895     }
22896   }
22897
22898   jresult = result;
22899
22900   //argout typemap for const std::string&
22901
22902
22903   //argout typemap for const std::string&
22904
22905   return jresult;
22906 }
22907
22908
22909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22910   float jresult ;
22911   float result;
22912
22913   result = (float)(float)Dali::ParentOrigin::TOP;
22914   jresult = result;
22915   return jresult;
22916 }
22917
22918
22919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22920   float jresult ;
22921   float result;
22922
22923   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22924   jresult = result;
22925   return jresult;
22926 }
22927
22928
22929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22930   float jresult ;
22931   float result;
22932
22933   result = (float)(float)Dali::ParentOrigin::LEFT;
22934   jresult = result;
22935   return jresult;
22936 }
22937
22938
22939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22940   float jresult ;
22941   float result;
22942
22943   result = (float)(float)Dali::ParentOrigin::RIGHT;
22944   jresult = result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22950   float jresult ;
22951   float result;
22952
22953   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22954   jresult = result;
22955   return jresult;
22956 }
22957
22958
22959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22960   void * jresult ;
22961   Dali::Vector3 *result = 0 ;
22962
22963   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22964   jresult = (void *)result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22970   void * jresult ;
22971   Dali::Vector3 *result = 0 ;
22972
22973   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22974   jresult = (void *)result;
22975   return jresult;
22976 }
22977
22978
22979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22980   void * jresult ;
22981   Dali::Vector3 *result = 0 ;
22982
22983   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22984   jresult = (void *)result;
22985   return jresult;
22986 }
22987
22988
22989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22990   void * jresult ;
22991   Dali::Vector3 *result = 0 ;
22992
22993   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22994   jresult = (void *)result;
22995   return jresult;
22996 }
22997
22998
22999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23000   void * jresult ;
23001   Dali::Vector3 *result = 0 ;
23002
23003   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23004   jresult = (void *)result;
23005   return jresult;
23006 }
23007
23008
23009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23010   void * jresult ;
23011   Dali::Vector3 *result = 0 ;
23012
23013   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23014   jresult = (void *)result;
23015   return jresult;
23016 }
23017
23018
23019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23020   void * jresult ;
23021   Dali::Vector3 *result = 0 ;
23022
23023   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23030   void * jresult ;
23031   Dali::Vector3 *result = 0 ;
23032
23033   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23034   jresult = (void *)result;
23035   return jresult;
23036 }
23037
23038
23039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23040   void * jresult ;
23041   Dali::Vector3 *result = 0 ;
23042
23043   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23044   jresult = (void *)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23050   float jresult ;
23051   float result;
23052
23053   result = (float)(float)Dali::AnchorPoint::TOP;
23054   jresult = result;
23055   return jresult;
23056 }
23057
23058
23059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23060   float jresult ;
23061   float result;
23062
23063   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23064   jresult = result;
23065   return jresult;
23066 }
23067
23068
23069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23070   float jresult ;
23071   float result;
23072
23073   result = (float)(float)Dali::AnchorPoint::LEFT;
23074   jresult = result;
23075   return jresult;
23076 }
23077
23078
23079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23080   float jresult ;
23081   float result;
23082
23083   result = (float)(float)Dali::AnchorPoint::RIGHT;
23084   jresult = result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23090   float jresult ;
23091   float result;
23092
23093   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23094   jresult = result;
23095   return jresult;
23096 }
23097
23098
23099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23100   void * jresult ;
23101   Dali::Vector3 *result = 0 ;
23102
23103   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23104   jresult = (void *)result;
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23110   void * jresult ;
23111   Dali::Vector3 *result = 0 ;
23112
23113   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23114   jresult = (void *)result;
23115   return jresult;
23116 }
23117
23118
23119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23120   void * jresult ;
23121   Dali::Vector3 *result = 0 ;
23122
23123   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23124   jresult = (void *)result;
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23130   void * jresult ;
23131   Dali::Vector3 *result = 0 ;
23132
23133   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23134   jresult = (void *)result;
23135   return jresult;
23136 }
23137
23138
23139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23140   void * jresult ;
23141   Dali::Vector3 *result = 0 ;
23142
23143   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23144   jresult = (void *)result;
23145   return jresult;
23146 }
23147
23148
23149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23150   void * jresult ;
23151   Dali::Vector3 *result = 0 ;
23152
23153   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23154   jresult = (void *)result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23160   void * jresult ;
23161   Dali::Vector3 *result = 0 ;
23162
23163   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23170   void * jresult ;
23171   Dali::Vector3 *result = 0 ;
23172
23173   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23174   jresult = (void *)result;
23175   return jresult;
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23180   void * jresult ;
23181   Dali::Vector3 *result = 0 ;
23182
23183   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23184   jresult = (void *)result;
23185   return jresult;
23186 }
23187
23188
23189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23190   void * jresult ;
23191   Dali::Vector4 *result = 0 ;
23192
23193   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23194   jresult = (void *)result;
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23200   void * jresult ;
23201   Dali::Vector4 *result = 0 ;
23202
23203   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23204   jresult = (void *)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23210   void * jresult ;
23211   Dali::Vector4 *result = 0 ;
23212
23213   result = (Dali::Vector4 *)&Dali::Color::RED;
23214   jresult = (void *)result;
23215   return jresult;
23216 }
23217
23218
23219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23220   void * jresult ;
23221   Dali::Vector4 *result = 0 ;
23222
23223   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23230   void * jresult ;
23231   Dali::Vector4 *result = 0 ;
23232
23233   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23240   void * jresult ;
23241   Dali::Vector4 *result = 0 ;
23242
23243   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23244   jresult = (void *)result;
23245   return jresult;
23246 }
23247
23248
23249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23250   void * jresult ;
23251   Dali::Vector4 *result = 0 ;
23252
23253   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23254   jresult = (void *)result;
23255   return jresult;
23256 }
23257
23258
23259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23260   void * jresult ;
23261   Dali::Vector4 *result = 0 ;
23262
23263   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23264   jresult = (void *)result;
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23270   void * jresult ;
23271   Dali::Vector4 *result = 0 ;
23272
23273   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23280   float jresult ;
23281   float result;
23282
23283   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23284   jresult = result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23290   float jresult ;
23291   float result;
23292
23293   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23294   jresult = result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23300   float jresult ;
23301   float result;
23302
23303   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23304   jresult = result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23310   float jresult ;
23311   float result;
23312
23313   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23314   jresult = result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23320   float jresult ;
23321   float result;
23322
23323   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23324   jresult = result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23330   float jresult ;
23331   float result;
23332
23333   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23334   jresult = result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23340   float jresult ;
23341   float result;
23342
23343   result = (float)(float)Dali::Math::PI;
23344   jresult = result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23350   float jresult ;
23351   float result;
23352
23353   result = (float)(float)Dali::Math::PI_2;
23354   jresult = result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23360   float jresult ;
23361   float result;
23362
23363   result = (float)(float)Dali::Math::PI_4;
23364   jresult = result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23370   float jresult ;
23371   float result;
23372
23373   result = (float)(float)Dali::Math::PI_OVER_180;
23374   jresult = result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23380   float jresult ;
23381   float result;
23382
23383   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23384   jresult = result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23390   int jresult ;
23391   Dali::ResizePolicy::Type result;
23392
23393   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23400   unsigned long jresult ;
23401   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23402   Dali::VectorBase::SizeType result;
23403
23404   arg1 = (Dali::VectorBase *)jarg1;
23405   {
23406     try {
23407       result = ((Dali::VectorBase const *)arg1)->Count();
23408     } catch (std::out_of_range& e) {
23409       {
23410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23411       };
23412     } catch (std::exception& e) {
23413       {
23414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23415       };
23416     } catch (Dali::DaliException e) {
23417       {
23418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23419       };
23420     } catch (...) {
23421       {
23422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23423       };
23424     }
23425   }
23426
23427   jresult = (unsigned long)result;
23428   return jresult;
23429 }
23430
23431
23432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23433   unsigned long jresult ;
23434   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23435   Dali::VectorBase::SizeType result;
23436
23437   arg1 = (Dali::VectorBase *)jarg1;
23438   {
23439     try {
23440       result = ((Dali::VectorBase const *)arg1)->Size();
23441     } catch (std::out_of_range& e) {
23442       {
23443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23444       };
23445     } catch (std::exception& e) {
23446       {
23447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23448       };
23449     } catch (Dali::DaliException e) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23452       };
23453     } catch (...) {
23454       {
23455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23456       };
23457     }
23458   }
23459
23460   jresult = (unsigned long)result;
23461   return jresult;
23462 }
23463
23464
23465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23466   unsigned int jresult ;
23467   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23468   bool result;
23469
23470   arg1 = (Dali::VectorBase *)jarg1;
23471   {
23472     try {
23473       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23474     } catch (std::out_of_range& e) {
23475       {
23476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23477       };
23478     } catch (std::exception& e) {
23479       {
23480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23481       };
23482     } catch (Dali::DaliException e) {
23483       {
23484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23485       };
23486     } catch (...) {
23487       {
23488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23489       };
23490     }
23491   }
23492
23493   jresult = result;
23494   return jresult;
23495 }
23496
23497
23498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23499   unsigned long jresult ;
23500   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23501   Dali::VectorBase::SizeType result;
23502
23503   arg1 = (Dali::VectorBase *)jarg1;
23504   {
23505     try {
23506       result = ((Dali::VectorBase const *)arg1)->Capacity();
23507     } catch (std::out_of_range& e) {
23508       {
23509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23510       };
23511     } catch (std::exception& e) {
23512       {
23513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23514       };
23515     } catch (Dali::DaliException e) {
23516       {
23517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23518       };
23519     } catch (...) {
23520       {
23521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23522       };
23523     }
23524   }
23525
23526   jresult = (unsigned long)result;
23527   return jresult;
23528 }
23529
23530
23531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23532   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23533
23534   arg1 = (Dali::VectorBase *)jarg1;
23535   {
23536     try {
23537       (arg1)->Release();
23538     } catch (std::out_of_range& e) {
23539       {
23540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23541       };
23542     } catch (std::exception& e) {
23543       {
23544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23545       };
23546     } catch (Dali::DaliException e) {
23547       {
23548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23549       };
23550     } catch (...) {
23551       {
23552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23553       };
23554     }
23555   }
23556
23557 }
23558
23559
23560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23561   void * jresult ;
23562   Dali::Image *result = 0 ;
23563
23564   {
23565     try {
23566       result = (Dali::Image *)new Dali::Image();
23567     } catch (std::out_of_range& e) {
23568       {
23569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (std::exception& e) {
23572       {
23573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23574       };
23575     } catch (Dali::DaliException e) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23578       };
23579     } catch (...) {
23580       {
23581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23582       };
23583     }
23584   }
23585
23586   jresult = (void *)result;
23587   return jresult;
23588 }
23589
23590
23591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23592   Dali::Image *arg1 = (Dali::Image *) 0 ;
23593
23594   arg1 = (Dali::Image *)jarg1;
23595   {
23596     try {
23597       delete arg1;
23598     } catch (std::out_of_range& e) {
23599       {
23600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (std::exception& e) {
23603       {
23604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23605       };
23606     } catch (Dali::DaliException e) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23609       };
23610     } catch (...) {
23611       {
23612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23613       };
23614     }
23615   }
23616
23617 }
23618
23619
23620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23621   void * jresult ;
23622   Dali::Image *arg1 = 0 ;
23623   Dali::Image *result = 0 ;
23624
23625   arg1 = (Dali::Image *)jarg1;
23626   if (!arg1) {
23627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23628     return 0;
23629   }
23630   {
23631     try {
23632       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23633     } catch (std::out_of_range& e) {
23634       {
23635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23636       };
23637     } catch (std::exception& e) {
23638       {
23639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23640       };
23641     } catch (Dali::DaliException e) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23644       };
23645     } catch (...) {
23646       {
23647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23648       };
23649     }
23650   }
23651
23652   jresult = (void *)result;
23653   return jresult;
23654 }
23655
23656
23657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23658   void * jresult ;
23659   Dali::Image *arg1 = (Dali::Image *) 0 ;
23660   Dali::Image *arg2 = 0 ;
23661   Dali::Image *result = 0 ;
23662
23663   arg1 = (Dali::Image *)jarg1;
23664   arg2 = (Dali::Image *)jarg2;
23665   if (!arg2) {
23666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23667     return 0;
23668   }
23669   {
23670     try {
23671       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23672     } catch (std::out_of_range& e) {
23673       {
23674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23675       };
23676     } catch (std::exception& e) {
23677       {
23678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23679       };
23680     } catch (Dali::DaliException e) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23683       };
23684     } catch (...) {
23685       {
23686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23687       };
23688     }
23689   }
23690
23691   jresult = (void *)result;
23692   return jresult;
23693 }
23694
23695
23696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23697   void * jresult ;
23698   Dali::BaseHandle arg1 ;
23699   Dali::BaseHandle *argp1 ;
23700   Dali::Image result;
23701
23702   argp1 = (Dali::BaseHandle *)jarg1;
23703   if (!argp1) {
23704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23705     return 0;
23706   }
23707   arg1 = *argp1;
23708   {
23709     try {
23710       result = Dali::Image::DownCast(arg1);
23711     } catch (std::out_of_range& e) {
23712       {
23713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23714       };
23715     } catch (std::exception& e) {
23716       {
23717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23718       };
23719     } catch (Dali::DaliException e) {
23720       {
23721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23726       };
23727     }
23728   }
23729
23730   jresult = new Dali::Image((const Dali::Image &)result);
23731   return jresult;
23732 }
23733
23734
23735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23736   unsigned int jresult ;
23737   Dali::Image *arg1 = (Dali::Image *) 0 ;
23738   unsigned int result;
23739
23740   arg1 = (Dali::Image *)jarg1;
23741   {
23742     try {
23743       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23744     } catch (std::out_of_range& e) {
23745       {
23746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (std::exception& e) {
23749       {
23750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (Dali::DaliException e) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762
23763   jresult = result;
23764   return jresult;
23765 }
23766
23767
23768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23769   unsigned int jresult ;
23770   Dali::Image *arg1 = (Dali::Image *) 0 ;
23771   unsigned int result;
23772
23773   arg1 = (Dali::Image *)jarg1;
23774   {
23775     try {
23776       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23777     } catch (std::out_of_range& e) {
23778       {
23779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (std::exception& e) {
23782       {
23783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23784       };
23785     } catch (Dali::DaliException e) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23788       };
23789     } catch (...) {
23790       {
23791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23792       };
23793     }
23794   }
23795
23796   jresult = result;
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23802   void * jresult ;
23803   Dali::Image *arg1 = (Dali::Image *) 0 ;
23804   Dali::Image::ImageSignalType *result = 0 ;
23805
23806   arg1 = (Dali::Image *)jarg1;
23807   {
23808     try {
23809       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23810     } catch (std::out_of_range& e) {
23811       {
23812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23813       };
23814     } catch (std::exception& e) {
23815       {
23816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23817       };
23818     } catch (Dali::DaliException e) {
23819       {
23820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23825       };
23826     }
23827   }
23828
23829   jresult = (void *)result;
23830   return jresult;
23831 }
23832
23833
23834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23835   int jresult ;
23836   Dali::Pixel::Format result;
23837
23838   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23839   jresult = (int)result;
23840   return jresult;
23841 }
23842
23843
23844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23845   int jresult ;
23846   Dali::Pixel::Format result;
23847
23848   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23849   jresult = (int)result;
23850   return jresult;
23851 }
23852
23853
23854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23855   unsigned int jresult ;
23856   Dali::Pixel::Format arg1 ;
23857   bool result;
23858
23859   arg1 = (Dali::Pixel::Format)jarg1;
23860   {
23861     try {
23862       result = (bool)Dali::Pixel::HasAlpha(arg1);
23863     } catch (std::out_of_range& e) {
23864       {
23865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (std::exception& e) {
23868       {
23869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23870       };
23871     } catch (Dali::DaliException e) {
23872       {
23873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23874       };
23875     } catch (...) {
23876       {
23877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23878       };
23879     }
23880   }
23881
23882   jresult = result;
23883   return jresult;
23884 }
23885
23886
23887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23888   unsigned int jresult ;
23889   Dali::Pixel::Format arg1 ;
23890   unsigned int result;
23891
23892   arg1 = (Dali::Pixel::Format)jarg1;
23893   {
23894     try {
23895       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23896     } catch (std::out_of_range& e) {
23897       {
23898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23899       };
23900     } catch (std::exception& e) {
23901       {
23902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (Dali::DaliException e) {
23905       {
23906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23907       };
23908     } catch (...) {
23909       {
23910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23911       };
23912     }
23913   }
23914
23915   jresult = result;
23916   return jresult;
23917 }
23918
23919
23920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23921   Dali::Pixel::Format arg1 ;
23922   int *arg2 = 0 ;
23923   int *arg3 = 0 ;
23924
23925   arg1 = (Dali::Pixel::Format)jarg1;
23926   arg2 = (int *)jarg2;
23927   if (!arg2) {
23928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23929     return ;
23930   }
23931   arg3 = (int *)jarg3;
23932   if (!arg3) {
23933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23934     return ;
23935   }
23936   {
23937     try {
23938       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23939     } catch (std::out_of_range& e) {
23940       {
23941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23942       };
23943     } catch (std::exception& e) {
23944       {
23945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23946       };
23947     } catch (Dali::DaliException e) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23950       };
23951     } catch (...) {
23952       {
23953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23954       };
23955     }
23956   }
23957
23958 }
23959
23960
23961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23962   void * jresult ;
23963   unsigned char *arg1 = (unsigned char *) 0 ;
23964   unsigned int arg2 ;
23965   unsigned int arg3 ;
23966   unsigned int arg4 ;
23967   Dali::Pixel::Format arg5 ;
23968   Dali::PixelData::ReleaseFunction arg6 ;
23969   Dali::PixelData result;
23970
23971   arg1 = jarg1;
23972   arg2 = (unsigned int)jarg2;
23973   arg3 = (unsigned int)jarg3;
23974   arg4 = (unsigned int)jarg4;
23975   arg5 = (Dali::Pixel::Format)jarg5;
23976   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23977   {
23978     try {
23979       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
23980     } catch (std::out_of_range& e) {
23981       {
23982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23983       };
23984     } catch (std::exception& e) {
23985       {
23986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (Dali::DaliException e) {
23989       {
23990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23991       };
23992     } catch (...) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23995       };
23996     }
23997   }
23998
23999   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24000
24001
24002   return jresult;
24003 }
24004
24005
24006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24007   void * jresult ;
24008   Dali::PixelData *result = 0 ;
24009
24010   {
24011     try {
24012       result = (Dali::PixelData *)new Dali::PixelData();
24013     } catch (std::out_of_range& e) {
24014       {
24015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24016       };
24017     } catch (std::exception& e) {
24018       {
24019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (Dali::DaliException e) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24024       };
24025     } catch (...) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24028       };
24029     }
24030   }
24031
24032   jresult = (void *)result;
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24038   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24039
24040   arg1 = (Dali::PixelData *)jarg1;
24041   {
24042     try {
24043       delete arg1;
24044     } catch (std::out_of_range& e) {
24045       {
24046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24047       };
24048     } catch (std::exception& e) {
24049       {
24050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24051       };
24052     } catch (Dali::DaliException e) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24055       };
24056     } catch (...) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24059       };
24060     }
24061   }
24062
24063 }
24064
24065
24066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24067   void * jresult ;
24068   Dali::PixelData *arg1 = 0 ;
24069   Dali::PixelData *result = 0 ;
24070
24071   arg1 = (Dali::PixelData *)jarg1;
24072   if (!arg1) {
24073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24074     return 0;
24075   }
24076   {
24077     try {
24078       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24079     } catch (std::out_of_range& e) {
24080       {
24081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24082       };
24083     } catch (std::exception& e) {
24084       {
24085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (Dali::DaliException e) {
24088       {
24089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24090       };
24091     } catch (...) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24094       };
24095     }
24096   }
24097
24098   jresult = (void *)result;
24099   return jresult;
24100 }
24101
24102
24103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24104   void * jresult ;
24105   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24106   Dali::PixelData *arg2 = 0 ;
24107   Dali::PixelData *result = 0 ;
24108
24109   arg1 = (Dali::PixelData *)jarg1;
24110   arg2 = (Dali::PixelData *)jarg2;
24111   if (!arg2) {
24112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24113     return 0;
24114   }
24115   {
24116     try {
24117       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24118     } catch (std::out_of_range& e) {
24119       {
24120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24121       };
24122     } catch (std::exception& e) {
24123       {
24124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (Dali::DaliException e) {
24127       {
24128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24129       };
24130     } catch (...) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24133       };
24134     }
24135   }
24136
24137   jresult = (void *)result;
24138   return jresult;
24139 }
24140
24141
24142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24143   unsigned int jresult ;
24144   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24145   unsigned int result;
24146
24147   arg1 = (Dali::PixelData *)jarg1;
24148   {
24149     try {
24150       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24151     } catch (std::out_of_range& e) {
24152       {
24153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24154       };
24155     } catch (std::exception& e) {
24156       {
24157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (Dali::DaliException e) {
24160       {
24161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24162       };
24163     } catch (...) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24166       };
24167     }
24168   }
24169
24170   jresult = result;
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24176   unsigned int jresult ;
24177   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24178   unsigned int result;
24179
24180   arg1 = (Dali::PixelData *)jarg1;
24181   {
24182     try {
24183       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24184     } catch (std::out_of_range& e) {
24185       {
24186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24187       };
24188     } catch (std::exception& e) {
24189       {
24190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24191       };
24192     } catch (Dali::DaliException e) {
24193       {
24194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24195       };
24196     } catch (...) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24199       };
24200     }
24201   }
24202
24203   jresult = result;
24204   return jresult;
24205 }
24206
24207
24208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24209   int jresult ;
24210   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24211   Dali::Pixel::Format result;
24212
24213   arg1 = (Dali::PixelData *)jarg1;
24214   {
24215     try {
24216       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24217     } catch (std::out_of_range& e) {
24218       {
24219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24220       };
24221     } catch (std::exception& e) {
24222       {
24223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24224       };
24225     } catch (Dali::DaliException e) {
24226       {
24227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24228       };
24229     } catch (...) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24232       };
24233     }
24234   }
24235
24236   jresult = (int)result;
24237   return jresult;
24238 }
24239
24240
24241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24242   unsigned int jresult ;
24243   unsigned int result;
24244
24245   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24246   jresult = result;
24247   return jresult;
24248 }
24249
24250
24251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24252   unsigned int jresult ;
24253   unsigned int result;
24254
24255   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24256   jresult = result;
24257   return jresult;
24258 }
24259
24260
24261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24262   unsigned int jresult ;
24263   unsigned int result;
24264
24265   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24266   jresult = result;
24267   return jresult;
24268 }
24269
24270
24271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24272   unsigned int jresult ;
24273   unsigned int result;
24274
24275   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24276   jresult = result;
24277   return jresult;
24278 }
24279
24280
24281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24282   unsigned int jresult ;
24283   unsigned int result;
24284
24285   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24286   jresult = result;
24287   return jresult;
24288 }
24289
24290
24291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24292   unsigned int jresult ;
24293   unsigned int result;
24294
24295   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24296   jresult = result;
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24302   void * jresult ;
24303   Dali::TextureType::Type arg1 ;
24304   Dali::Pixel::Format arg2 ;
24305   unsigned int arg3 ;
24306   unsigned int arg4 ;
24307   Dali::Texture result;
24308
24309   arg1 = (Dali::TextureType::Type)jarg1;
24310   arg2 = (Dali::Pixel::Format)jarg2;
24311   arg3 = (unsigned int)jarg3;
24312   arg4 = (unsigned int)jarg4;
24313   {
24314     try {
24315       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24316     } catch (std::out_of_range& e) {
24317       {
24318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24319       };
24320     } catch (std::exception& e) {
24321       {
24322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (Dali::DaliException e) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24327       };
24328     } catch (...) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24331       };
24332     }
24333   }
24334
24335   jresult = new Dali::Texture((const Dali::Texture &)result);
24336   return jresult;
24337 }
24338
24339
24340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24341   void * jresult ;
24342   NativeImageInterface *arg1 = 0 ;
24343   Dali::Texture result;
24344
24345   arg1 = (NativeImageInterface *)jarg1;
24346   if (!arg1) {
24347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24348     return 0;
24349   }
24350   {
24351     try {
24352       result = Dali::Texture::New(*arg1);
24353     } catch (std::out_of_range& e) {
24354       {
24355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24356       };
24357     } catch (std::exception& e) {
24358       {
24359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (Dali::DaliException e) {
24362       {
24363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24364       };
24365     } catch (...) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24368       };
24369     }
24370   }
24371
24372   jresult = new Dali::Texture((const Dali::Texture &)result);
24373   return jresult;
24374 }
24375
24376
24377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24378   void * jresult ;
24379   Dali::Texture *result = 0 ;
24380
24381   {
24382     try {
24383       result = (Dali::Texture *)new Dali::Texture();
24384     } catch (std::out_of_range& e) {
24385       {
24386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (std::exception& e) {
24389       {
24390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (Dali::DaliException e) {
24393       {
24394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24395       };
24396     } catch (...) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24399       };
24400     }
24401   }
24402
24403   jresult = (void *)result;
24404   return jresult;
24405 }
24406
24407
24408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24409   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24410
24411   arg1 = (Dali::Texture *)jarg1;
24412   {
24413     try {
24414       delete arg1;
24415     } catch (std::out_of_range& e) {
24416       {
24417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24418       };
24419     } catch (std::exception& e) {
24420       {
24421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24422       };
24423     } catch (Dali::DaliException e) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24426       };
24427     } catch (...) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24430       };
24431     }
24432   }
24433
24434 }
24435
24436
24437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24438   void * jresult ;
24439   Dali::Texture *arg1 = 0 ;
24440   Dali::Texture *result = 0 ;
24441
24442   arg1 = (Dali::Texture *)jarg1;
24443   if (!arg1) {
24444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24445     return 0;
24446   }
24447   {
24448     try {
24449       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24450     } catch (std::out_of_range& e) {
24451       {
24452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24453       };
24454     } catch (std::exception& e) {
24455       {
24456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24457       };
24458     } catch (Dali::DaliException e) {
24459       {
24460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24461       };
24462     } catch (...) {
24463       {
24464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24465       };
24466     }
24467   }
24468
24469   jresult = (void *)result;
24470   return jresult;
24471 }
24472
24473
24474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24475   void * jresult ;
24476   Dali::BaseHandle arg1 ;
24477   Dali::BaseHandle *argp1 ;
24478   Dali::Texture result;
24479
24480   argp1 = (Dali::BaseHandle *)jarg1;
24481   if (!argp1) {
24482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24483     return 0;
24484   }
24485   arg1 = *argp1;
24486   {
24487     try {
24488       result = Dali::Texture::DownCast(arg1);
24489     } catch (std::out_of_range& e) {
24490       {
24491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24492       };
24493     } catch (std::exception& e) {
24494       {
24495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24496       };
24497     } catch (Dali::DaliException e) {
24498       {
24499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24500       };
24501     } catch (...) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24504       };
24505     }
24506   }
24507
24508   jresult = new Dali::Texture((const Dali::Texture &)result);
24509   return jresult;
24510 }
24511
24512
24513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24514   void * jresult ;
24515   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24516   Dali::Texture *arg2 = 0 ;
24517   Dali::Texture *result = 0 ;
24518
24519   arg1 = (Dali::Texture *)jarg1;
24520   arg2 = (Dali::Texture *)jarg2;
24521   if (!arg2) {
24522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24523     return 0;
24524   }
24525   {
24526     try {
24527       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24528     } catch (std::out_of_range& e) {
24529       {
24530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24531       };
24532     } catch (std::exception& e) {
24533       {
24534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (Dali::DaliException e) {
24537       {
24538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24539       };
24540     } catch (...) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24543       };
24544     }
24545   }
24546
24547   jresult = (void *)result;
24548   return jresult;
24549 }
24550
24551
24552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24553   unsigned int jresult ;
24554   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24555   Dali::PixelData arg2 ;
24556   Dali::PixelData *argp2 ;
24557   bool result;
24558
24559   arg1 = (Dali::Texture *)jarg1;
24560   argp2 = (Dali::PixelData *)jarg2;
24561   if (!argp2) {
24562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24563     return 0;
24564   }
24565   arg2 = *argp2;
24566   {
24567     try {
24568       result = (bool)(arg1)->Upload(arg2);
24569     } catch (std::out_of_range& e) {
24570       {
24571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (std::exception& e) {
24574       {
24575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (Dali::DaliException e) {
24578       {
24579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24580       };
24581     } catch (...) {
24582       {
24583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24584       };
24585     }
24586   }
24587
24588   jresult = result;
24589   return jresult;
24590 }
24591
24592
24593 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) {
24594   unsigned int jresult ;
24595   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24596   Dali::PixelData arg2 ;
24597   unsigned int arg3 ;
24598   unsigned int arg4 ;
24599   unsigned int arg5 ;
24600   unsigned int arg6 ;
24601   unsigned int arg7 ;
24602   unsigned int arg8 ;
24603   Dali::PixelData *argp2 ;
24604   bool result;
24605
24606   arg1 = (Dali::Texture *)jarg1;
24607   argp2 = (Dali::PixelData *)jarg2;
24608   if (!argp2) {
24609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24610     return 0;
24611   }
24612   arg2 = *argp2;
24613   arg3 = (unsigned int)jarg3;
24614   arg4 = (unsigned int)jarg4;
24615   arg5 = (unsigned int)jarg5;
24616   arg6 = (unsigned int)jarg6;
24617   arg7 = (unsigned int)jarg7;
24618   arg8 = (unsigned int)jarg8;
24619   {
24620     try {
24621       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24622     } catch (std::out_of_range& e) {
24623       {
24624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24625       };
24626     } catch (std::exception& e) {
24627       {
24628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (Dali::DaliException e) {
24631       {
24632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24633       };
24634     } catch (...) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24637       };
24638     }
24639   }
24640
24641   jresult = result;
24642   return jresult;
24643 }
24644
24645
24646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24647   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24648
24649   arg1 = (Dali::Texture *)jarg1;
24650   {
24651     try {
24652       (arg1)->GenerateMipmaps();
24653     } catch (std::out_of_range& e) {
24654       {
24655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24656       };
24657     } catch (std::exception& e) {
24658       {
24659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24660       };
24661     } catch (Dali::DaliException e) {
24662       {
24663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24664       };
24665     } catch (...) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24668       };
24669     }
24670   }
24671
24672 }
24673
24674
24675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24676   unsigned int jresult ;
24677   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24678   unsigned int result;
24679
24680   arg1 = (Dali::Texture *)jarg1;
24681   {
24682     try {
24683       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24684     } catch (std::out_of_range& e) {
24685       {
24686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24687       };
24688     } catch (std::exception& e) {
24689       {
24690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24691       };
24692     } catch (Dali::DaliException e) {
24693       {
24694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24695       };
24696     } catch (...) {
24697       {
24698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24699       };
24700     }
24701   }
24702
24703   jresult = result;
24704   return jresult;
24705 }
24706
24707
24708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24709   unsigned int jresult ;
24710   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24711   unsigned int result;
24712
24713   arg1 = (Dali::Texture *)jarg1;
24714   {
24715     try {
24716       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24717     } catch (std::out_of_range& e) {
24718       {
24719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24720       };
24721     } catch (std::exception& e) {
24722       {
24723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24724       };
24725     } catch (Dali::DaliException e) {
24726       {
24727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24728       };
24729     } catch (...) {
24730       {
24731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24732       };
24733     }
24734   }
24735
24736   jresult = result;
24737   return jresult;
24738 }
24739
24740
24741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24742   void * jresult ;
24743   Dali::Sampler result;
24744
24745   {
24746     try {
24747       result = Dali::Sampler::New();
24748     } catch (std::out_of_range& e) {
24749       {
24750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24751       };
24752     } catch (std::exception& e) {
24753       {
24754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24755       };
24756     } catch (Dali::DaliException e) {
24757       {
24758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24759       };
24760     } catch (...) {
24761       {
24762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24763       };
24764     }
24765   }
24766
24767   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24773   void * jresult ;
24774   Dali::Sampler *result = 0 ;
24775
24776   {
24777     try {
24778       result = (Dali::Sampler *)new Dali::Sampler();
24779     } catch (std::out_of_range& e) {
24780       {
24781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24782       };
24783     } catch (std::exception& e) {
24784       {
24785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (Dali::DaliException e) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24790       };
24791     } catch (...) {
24792       {
24793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24794       };
24795     }
24796   }
24797
24798   jresult = (void *)result;
24799   return jresult;
24800 }
24801
24802
24803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24804   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24805
24806   arg1 = (Dali::Sampler *)jarg1;
24807   {
24808     try {
24809       delete arg1;
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (Dali::DaliException e) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24821       };
24822     } catch (...) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24825       };
24826     }
24827   }
24828
24829 }
24830
24831
24832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24833   void * jresult ;
24834   Dali::Sampler *arg1 = 0 ;
24835   Dali::Sampler *result = 0 ;
24836
24837   arg1 = (Dali::Sampler *)jarg1;
24838   if (!arg1) {
24839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24840     return 0;
24841   }
24842   {
24843     try {
24844       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24845     } catch (std::out_of_range& e) {
24846       {
24847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24848       };
24849     } catch (std::exception& e) {
24850       {
24851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (Dali::DaliException e) {
24854       {
24855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24856       };
24857     } catch (...) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24860       };
24861     }
24862   }
24863
24864   jresult = (void *)result;
24865   return jresult;
24866 }
24867
24868
24869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24870   void * jresult ;
24871   Dali::BaseHandle arg1 ;
24872   Dali::BaseHandle *argp1 ;
24873   Dali::Sampler result;
24874
24875   argp1 = (Dali::BaseHandle *)jarg1;
24876   if (!argp1) {
24877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24878     return 0;
24879   }
24880   arg1 = *argp1;
24881   {
24882     try {
24883       result = Dali::Sampler::DownCast(arg1);
24884     } catch (std::out_of_range& e) {
24885       {
24886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24887       };
24888     } catch (std::exception& e) {
24889       {
24890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24891       };
24892     } catch (Dali::DaliException e) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24895       };
24896     } catch (...) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24899       };
24900     }
24901   }
24902
24903   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24904   return jresult;
24905 }
24906
24907
24908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24909   void * jresult ;
24910   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24911   Dali::Sampler *arg2 = 0 ;
24912   Dali::Sampler *result = 0 ;
24913
24914   arg1 = (Dali::Sampler *)jarg1;
24915   arg2 = (Dali::Sampler *)jarg2;
24916   if (!arg2) {
24917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24918     return 0;
24919   }
24920   {
24921     try {
24922       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24923     } catch (std::out_of_range& e) {
24924       {
24925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (std::exception& e) {
24928       {
24929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24930       };
24931     } catch (Dali::DaliException e) {
24932       {
24933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24934       };
24935     } catch (...) {
24936       {
24937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24938       };
24939     }
24940   }
24941
24942   jresult = (void *)result;
24943   return jresult;
24944 }
24945
24946
24947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24948   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24949   Dali::FilterMode::Type arg2 ;
24950   Dali::FilterMode::Type arg3 ;
24951
24952   arg1 = (Dali::Sampler *)jarg1;
24953   arg2 = (Dali::FilterMode::Type)jarg2;
24954   arg3 = (Dali::FilterMode::Type)jarg3;
24955   {
24956     try {
24957       (arg1)->SetFilterMode(arg2,arg3);
24958     } catch (std::out_of_range& e) {
24959       {
24960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24961       };
24962     } catch (std::exception& e) {
24963       {
24964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (Dali::DaliException e) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24969       };
24970     } catch (...) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24973       };
24974     }
24975   }
24976
24977 }
24978
24979
24980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24981   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24982   Dali::WrapMode::Type arg2 ;
24983   Dali::WrapMode::Type arg3 ;
24984
24985   arg1 = (Dali::Sampler *)jarg1;
24986   arg2 = (Dali::WrapMode::Type)jarg2;
24987   arg3 = (Dali::WrapMode::Type)jarg3;
24988   {
24989     try {
24990       (arg1)->SetWrapMode(arg2,arg3);
24991     } catch (std::out_of_range& e) {
24992       {
24993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24994       };
24995     } catch (std::exception& e) {
24996       {
24997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (Dali::DaliException e) {
25000       {
25001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25002       };
25003     } catch (...) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25006       };
25007     }
25008   }
25009
25010 }
25011
25012
25013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25014   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25015   Dali::WrapMode::Type arg2 ;
25016   Dali::WrapMode::Type arg3 ;
25017   Dali::WrapMode::Type arg4 ;
25018
25019   arg1 = (Dali::Sampler *)jarg1;
25020   arg2 = (Dali::WrapMode::Type)jarg2;
25021   arg3 = (Dali::WrapMode::Type)jarg3;
25022   arg4 = (Dali::WrapMode::Type)jarg4;
25023   {
25024     try {
25025       (arg1)->SetWrapMode(arg2,arg3,arg4);
25026     } catch (std::out_of_range& e) {
25027       {
25028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25029       };
25030     } catch (std::exception& e) {
25031       {
25032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25033       };
25034     } catch (Dali::DaliException e) {
25035       {
25036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25037       };
25038     } catch (...) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25041       };
25042     }
25043   }
25044
25045 }
25046
25047
25048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25049   void * jresult ;
25050   Dali::TextureSet result;
25051
25052   {
25053     try {
25054       result = Dali::TextureSet::New();
25055     } catch (std::out_of_range& e) {
25056       {
25057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25058       };
25059     } catch (std::exception& e) {
25060       {
25061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25062       };
25063     } catch (Dali::DaliException e) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25066       };
25067     } catch (...) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25070       };
25071     }
25072   }
25073
25074   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25075   return jresult;
25076 }
25077
25078
25079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25080   void * jresult ;
25081   Dali::TextureSet *result = 0 ;
25082
25083   {
25084     try {
25085       result = (Dali::TextureSet *)new Dali::TextureSet();
25086     } catch (std::out_of_range& e) {
25087       {
25088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25089       };
25090     } catch (std::exception& e) {
25091       {
25092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (Dali::DaliException e) {
25095       {
25096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25097       };
25098     } catch (...) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25101       };
25102     }
25103   }
25104
25105   jresult = (void *)result;
25106   return jresult;
25107 }
25108
25109
25110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25111   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25112
25113   arg1 = (Dali::TextureSet *)jarg1;
25114   {
25115     try {
25116       delete arg1;
25117     } catch (std::out_of_range& e) {
25118       {
25119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25120       };
25121     } catch (std::exception& e) {
25122       {
25123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (Dali::DaliException e) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25132       };
25133     }
25134   }
25135
25136 }
25137
25138
25139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25140   void * jresult ;
25141   Dali::TextureSet *arg1 = 0 ;
25142   Dali::TextureSet *result = 0 ;
25143
25144   arg1 = (Dali::TextureSet *)jarg1;
25145   if (!arg1) {
25146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25147     return 0;
25148   }
25149   {
25150     try {
25151       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25152     } catch (std::out_of_range& e) {
25153       {
25154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25155       };
25156     } catch (std::exception& e) {
25157       {
25158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (Dali::DaliException e) {
25161       {
25162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25163       };
25164     } catch (...) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25167       };
25168     }
25169   }
25170
25171   jresult = (void *)result;
25172   return jresult;
25173 }
25174
25175
25176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25177   void * jresult ;
25178   Dali::BaseHandle arg1 ;
25179   Dali::BaseHandle *argp1 ;
25180   Dali::TextureSet result;
25181
25182   argp1 = (Dali::BaseHandle *)jarg1;
25183   if (!argp1) {
25184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25185     return 0;
25186   }
25187   arg1 = *argp1;
25188   {
25189     try {
25190       result = Dali::TextureSet::DownCast(arg1);
25191     } catch (std::out_of_range& e) {
25192       {
25193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25194       };
25195     } catch (std::exception& e) {
25196       {
25197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (Dali::DaliException e) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25202       };
25203     } catch (...) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25206       };
25207     }
25208   }
25209
25210   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25211   return jresult;
25212 }
25213
25214
25215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25216   void * jresult ;
25217   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25218   Dali::TextureSet *arg2 = 0 ;
25219   Dali::TextureSet *result = 0 ;
25220
25221   arg1 = (Dali::TextureSet *)jarg1;
25222   arg2 = (Dali::TextureSet *)jarg2;
25223   if (!arg2) {
25224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25225     return 0;
25226   }
25227   {
25228     try {
25229       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25230     } catch (std::out_of_range& e) {
25231       {
25232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (std::exception& e) {
25235       {
25236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (Dali::DaliException e) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25241       };
25242     } catch (...) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25245       };
25246     }
25247   }
25248
25249   jresult = (void *)result;
25250   return jresult;
25251 }
25252
25253
25254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25255   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25256   size_t arg2 ;
25257   Dali::Texture arg3 ;
25258   Dali::Texture *argp3 ;
25259
25260   arg1 = (Dali::TextureSet *)jarg1;
25261   arg2 = (size_t)jarg2;
25262   argp3 = (Dali::Texture *)jarg3;
25263   if (!argp3) {
25264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25265     return ;
25266   }
25267   arg3 = *argp3;
25268   {
25269     try {
25270       (arg1)->SetTexture(arg2,arg3);
25271     } catch (std::out_of_range& e) {
25272       {
25273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25274       };
25275     } catch (std::exception& e) {
25276       {
25277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (Dali::DaliException e) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25282       };
25283     } catch (...) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25286       };
25287     }
25288   }
25289
25290 }
25291
25292
25293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25294   void * jresult ;
25295   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25296   size_t arg2 ;
25297   Dali::Texture result;
25298
25299   arg1 = (Dali::TextureSet *)jarg1;
25300   arg2 = (size_t)jarg2;
25301   {
25302     try {
25303       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25304     } catch (std::out_of_range& e) {
25305       {
25306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25307       };
25308     } catch (std::exception& e) {
25309       {
25310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (Dali::DaliException e) {
25313       {
25314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25315       };
25316     } catch (...) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25319       };
25320     }
25321   }
25322
25323   jresult = new Dali::Texture((const Dali::Texture &)result);
25324   return jresult;
25325 }
25326
25327
25328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25330   size_t arg2 ;
25331   Dali::Sampler arg3 ;
25332   Dali::Sampler *argp3 ;
25333
25334   arg1 = (Dali::TextureSet *)jarg1;
25335   arg2 = (size_t)jarg2;
25336   argp3 = (Dali::Sampler *)jarg3;
25337   if (!argp3) {
25338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25339     return ;
25340   }
25341   arg3 = *argp3;
25342   {
25343     try {
25344       (arg1)->SetSampler(arg2,arg3);
25345     } catch (std::out_of_range& e) {
25346       {
25347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25348       };
25349     } catch (std::exception& e) {
25350       {
25351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (Dali::DaliException e) {
25354       {
25355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25356       };
25357     } catch (...) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25360       };
25361     }
25362   }
25363
25364 }
25365
25366
25367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25368   void * jresult ;
25369   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25370   size_t arg2 ;
25371   Dali::Sampler result;
25372
25373   arg1 = (Dali::TextureSet *)jarg1;
25374   arg2 = (size_t)jarg2;
25375   {
25376     try {
25377       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25378     } catch (std::out_of_range& e) {
25379       {
25380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (std::exception& e) {
25383       {
25384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (Dali::DaliException e) {
25387       {
25388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25389       };
25390     } catch (...) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25393       };
25394     }
25395   }
25396
25397   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25398   return jresult;
25399 }
25400
25401
25402 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25403   unsigned long jresult ;
25404   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25405   size_t result;
25406
25407   arg1 = (Dali::TextureSet *)jarg1;
25408   {
25409     try {
25410       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25411     } catch (std::out_of_range& e) {
25412       {
25413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25414       };
25415     } catch (std::exception& e) {
25416       {
25417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (Dali::DaliException e) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25422       };
25423     } catch (...) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25426       };
25427     }
25428   }
25429
25430   jresult = (unsigned long)result;
25431   return jresult;
25432 }
25433
25434
25435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25436   void * jresult ;
25437   Dali::Property::Map *arg1 = 0 ;
25438   Dali::PropertyBuffer result;
25439
25440   arg1 = (Dali::Property::Map *)jarg1;
25441   if (!arg1) {
25442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25443     return 0;
25444   }
25445   {
25446     try {
25447       result = Dali::PropertyBuffer::New(*arg1);
25448     } catch (std::out_of_range& e) {
25449       {
25450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25451       };
25452     } catch (std::exception& e) {
25453       {
25454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (Dali::DaliException e) {
25457       {
25458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466
25467   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25468   return jresult;
25469 }
25470
25471
25472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25473   void * jresult ;
25474   Dali::PropertyBuffer *result = 0 ;
25475
25476   {
25477     try {
25478       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25479     } catch (std::out_of_range& e) {
25480       {
25481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25482       };
25483     } catch (std::exception& e) {
25484       {
25485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25486       };
25487     } catch (Dali::DaliException e) {
25488       {
25489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25490       };
25491     } catch (...) {
25492       {
25493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25494       };
25495     }
25496   }
25497
25498   jresult = (void *)result;
25499   return jresult;
25500 }
25501
25502
25503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25504   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25505
25506   arg1 = (Dali::PropertyBuffer *)jarg1;
25507   {
25508     try {
25509       delete arg1;
25510     } catch (std::out_of_range& e) {
25511       {
25512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25513       };
25514     } catch (std::exception& e) {
25515       {
25516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25517       };
25518     } catch (Dali::DaliException e) {
25519       {
25520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25521       };
25522     } catch (...) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25525       };
25526     }
25527   }
25528
25529 }
25530
25531
25532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25533   void * jresult ;
25534   Dali::PropertyBuffer *arg1 = 0 ;
25535   Dali::PropertyBuffer *result = 0 ;
25536
25537   arg1 = (Dali::PropertyBuffer *)jarg1;
25538   if (!arg1) {
25539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25540     return 0;
25541   }
25542   {
25543     try {
25544       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25545     } catch (std::out_of_range& e) {
25546       {
25547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25548       };
25549     } catch (std::exception& e) {
25550       {
25551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (Dali::DaliException e) {
25554       {
25555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25556       };
25557     } catch (...) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25560       };
25561     }
25562   }
25563
25564   jresult = (void *)result;
25565   return jresult;
25566 }
25567
25568
25569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25570   void * jresult ;
25571   Dali::BaseHandle arg1 ;
25572   Dali::BaseHandle *argp1 ;
25573   Dali::PropertyBuffer result;
25574
25575   argp1 = (Dali::BaseHandle *)jarg1;
25576   if (!argp1) {
25577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25578     return 0;
25579   }
25580   arg1 = *argp1;
25581   {
25582     try {
25583       result = Dali::PropertyBuffer::DownCast(arg1);
25584     } catch (std::out_of_range& e) {
25585       {
25586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25587       };
25588     } catch (std::exception& e) {
25589       {
25590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25591       };
25592     } catch (Dali::DaliException e) {
25593       {
25594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25595       };
25596     } catch (...) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25599       };
25600     }
25601   }
25602
25603   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25604   return jresult;
25605 }
25606
25607
25608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25609   void * jresult ;
25610   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25611   Dali::PropertyBuffer *arg2 = 0 ;
25612   Dali::PropertyBuffer *result = 0 ;
25613
25614   arg1 = (Dali::PropertyBuffer *)jarg1;
25615   arg2 = (Dali::PropertyBuffer *)jarg2;
25616   if (!arg2) {
25617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25618     return 0;
25619   }
25620   {
25621     try {
25622       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25623     } catch (std::out_of_range& e) {
25624       {
25625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25626       };
25627     } catch (std::exception& e) {
25628       {
25629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (Dali::DaliException e) {
25632       {
25633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25634       };
25635     } catch (...) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25638       };
25639     }
25640   }
25641
25642   jresult = (void *)result;
25643   return jresult;
25644 }
25645
25646
25647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25648   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25649   void *arg2 = (void *) 0 ;
25650   std::size_t arg3 ;
25651
25652   arg1 = (Dali::PropertyBuffer *)jarg1;
25653   arg2 = jarg2;
25654   arg3 = (std::size_t)jarg3;
25655   {
25656     try {
25657       (arg1)->SetData((void const *)arg2,arg3);
25658     } catch (std::out_of_range& e) {
25659       {
25660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25661       };
25662     } catch (std::exception& e) {
25663       {
25664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (Dali::DaliException e) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25669       };
25670     } catch (...) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25673       };
25674     }
25675   }
25676
25677 }
25678
25679
25680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25681   unsigned long jresult ;
25682   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25683   std::size_t result;
25684
25685   arg1 = (Dali::PropertyBuffer *)jarg1;
25686   {
25687     try {
25688       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25689     } catch (std::out_of_range& e) {
25690       {
25691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25692       };
25693     } catch (std::exception& e) {
25694       {
25695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25696       };
25697     } catch (Dali::DaliException e) {
25698       {
25699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25700       };
25701     } catch (...) {
25702       {
25703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25704       };
25705     }
25706   }
25707
25708   jresult = (unsigned long)result;
25709   return jresult;
25710 }
25711
25712
25713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25714   void * jresult ;
25715   Dali::Geometry result;
25716
25717   {
25718     try {
25719       result = Dali::Geometry::New();
25720     } catch (std::out_of_range& e) {
25721       {
25722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25723       };
25724     } catch (std::exception& e) {
25725       {
25726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25727       };
25728     } catch (Dali::DaliException e) {
25729       {
25730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25731       };
25732     } catch (...) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25735       };
25736     }
25737   }
25738
25739   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25740   return jresult;
25741 }
25742
25743
25744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25745   void * jresult ;
25746   Dali::Geometry *result = 0 ;
25747
25748   {
25749     try {
25750       result = (Dali::Geometry *)new Dali::Geometry();
25751     } catch (std::out_of_range& e) {
25752       {
25753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (std::exception& e) {
25756       {
25757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (Dali::DaliException e) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25762       };
25763     } catch (...) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25766       };
25767     }
25768   }
25769
25770   jresult = (void *)result;
25771   return jresult;
25772 }
25773
25774
25775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25776   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25777
25778   arg1 = (Dali::Geometry *)jarg1;
25779   {
25780     try {
25781       delete arg1;
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (Dali::DaliException e) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25797       };
25798     }
25799   }
25800
25801 }
25802
25803
25804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25805   void * jresult ;
25806   Dali::Geometry *arg1 = 0 ;
25807   Dali::Geometry *result = 0 ;
25808
25809   arg1 = (Dali::Geometry *)jarg1;
25810   if (!arg1) {
25811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25812     return 0;
25813   }
25814   {
25815     try {
25816       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25817     } catch (std::out_of_range& e) {
25818       {
25819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25820       };
25821     } catch (std::exception& e) {
25822       {
25823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (Dali::DaliException e) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25828       };
25829     } catch (...) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25832       };
25833     }
25834   }
25835
25836   jresult = (void *)result;
25837   return jresult;
25838 }
25839
25840
25841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25842   void * jresult ;
25843   Dali::BaseHandle arg1 ;
25844   Dali::BaseHandle *argp1 ;
25845   Dali::Geometry result;
25846
25847   argp1 = (Dali::BaseHandle *)jarg1;
25848   if (!argp1) {
25849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25850     return 0;
25851   }
25852   arg1 = *argp1;
25853   {
25854     try {
25855       result = Dali::Geometry::DownCast(arg1);
25856     } catch (std::out_of_range& e) {
25857       {
25858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25859       };
25860     } catch (std::exception& e) {
25861       {
25862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (Dali::DaliException e) {
25865       {
25866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25867       };
25868     } catch (...) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25871       };
25872     }
25873   }
25874
25875   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25876   return jresult;
25877 }
25878
25879
25880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25881   void * jresult ;
25882   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25883   Dali::Geometry *arg2 = 0 ;
25884   Dali::Geometry *result = 0 ;
25885
25886   arg1 = (Dali::Geometry *)jarg1;
25887   arg2 = (Dali::Geometry *)jarg2;
25888   if (!arg2) {
25889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25890     return 0;
25891   }
25892   {
25893     try {
25894       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25895     } catch (std::out_of_range& e) {
25896       {
25897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25898       };
25899     } catch (std::exception& e) {
25900       {
25901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (Dali::DaliException e) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25906       };
25907     } catch (...) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25910       };
25911     }
25912   }
25913
25914   jresult = (void *)result;
25915   return jresult;
25916 }
25917
25918
25919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25920   unsigned long jresult ;
25921   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25922   Dali::PropertyBuffer *arg2 = 0 ;
25923   std::size_t result;
25924
25925   arg1 = (Dali::Geometry *)jarg1;
25926   arg2 = (Dali::PropertyBuffer *)jarg2;
25927   if (!arg2) {
25928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25929     return 0;
25930   }
25931   {
25932     try {
25933       result = (arg1)->AddVertexBuffer(*arg2);
25934     } catch (std::out_of_range& e) {
25935       {
25936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25937       };
25938     } catch (std::exception& e) {
25939       {
25940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (Dali::DaliException e) {
25943       {
25944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25945       };
25946     } catch (...) {
25947       {
25948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25949       };
25950     }
25951   }
25952
25953   jresult = (unsigned long)result;
25954   return jresult;
25955 }
25956
25957
25958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25959   unsigned long jresult ;
25960   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25961   std::size_t result;
25962
25963   arg1 = (Dali::Geometry *)jarg1;
25964   {
25965     try {
25966       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25967     } catch (std::out_of_range& e) {
25968       {
25969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25970       };
25971     } catch (std::exception& e) {
25972       {
25973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (Dali::DaliException e) {
25976       {
25977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25978       };
25979     } catch (...) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25982       };
25983     }
25984   }
25985
25986   jresult = (unsigned long)result;
25987   return jresult;
25988 }
25989
25990
25991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25992   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25993   std::size_t arg2 ;
25994
25995   arg1 = (Dali::Geometry *)jarg1;
25996   arg2 = (std::size_t)jarg2;
25997   {
25998     try {
25999       (arg1)->RemoveVertexBuffer(arg2);
26000     } catch (std::out_of_range& e) {
26001       {
26002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26003       };
26004     } catch (std::exception& e) {
26005       {
26006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (Dali::DaliException e) {
26009       {
26010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26011       };
26012     } catch (...) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26015       };
26016     }
26017   }
26018
26019 }
26020
26021
26022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26023   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26024   unsigned short *arg2 = (unsigned short *) 0 ;
26025   size_t arg3 ;
26026
26027   arg1 = (Dali::Geometry *)jarg1;
26028   arg2 = jarg2;
26029   arg3 = (size_t)jarg3;
26030   {
26031     try {
26032       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26033     } catch (std::out_of_range& e) {
26034       {
26035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26036       };
26037     } catch (std::exception& e) {
26038       {
26039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26040       };
26041     } catch (Dali::DaliException e) {
26042       {
26043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26044       };
26045     } catch (...) {
26046       {
26047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26048       };
26049     }
26050   }
26051
26052
26053
26054 }
26055
26056
26057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26058   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26059   Dali::Geometry::Type arg2 ;
26060
26061   arg1 = (Dali::Geometry *)jarg1;
26062   arg2 = (Dali::Geometry::Type)jarg2;
26063   {
26064     try {
26065       (arg1)->SetType(arg2);
26066     } catch (std::out_of_range& e) {
26067       {
26068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26069       };
26070     } catch (std::exception& e) {
26071       {
26072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26073       };
26074     } catch (Dali::DaliException e) {
26075       {
26076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26077       };
26078     } catch (...) {
26079       {
26080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26081       };
26082     }
26083   }
26084
26085 }
26086
26087
26088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26089   int jresult ;
26090   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26091   Dali::Geometry::Type result;
26092
26093   arg1 = (Dali::Geometry *)jarg1;
26094   {
26095     try {
26096       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26097     } catch (std::out_of_range& e) {
26098       {
26099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26100       };
26101     } catch (std::exception& e) {
26102       {
26103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26104       };
26105     } catch (Dali::DaliException e) {
26106       {
26107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26108       };
26109     } catch (...) {
26110       {
26111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26112       };
26113     }
26114   }
26115
26116   jresult = (int)result;
26117   return jresult;
26118 }
26119
26120
26121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26122   void * jresult ;
26123   Dali::Shader::Hint *result = 0 ;
26124
26125   {
26126     try {
26127       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26128     } catch (std::out_of_range& e) {
26129       {
26130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26131       };
26132     } catch (std::exception& e) {
26133       {
26134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (Dali::DaliException e) {
26137       {
26138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26139       };
26140     } catch (...) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26143       };
26144     }
26145   }
26146
26147   jresult = (void *)result;
26148   return jresult;
26149 }
26150
26151
26152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26153   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26154
26155   arg1 = (Dali::Shader::Hint *)jarg1;
26156   {
26157     try {
26158       delete arg1;
26159     } catch (std::out_of_range& e) {
26160       {
26161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26162       };
26163     } catch (std::exception& e) {
26164       {
26165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26166       };
26167     } catch (Dali::DaliException e) {
26168       {
26169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26170       };
26171     } catch (...) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26174       };
26175     }
26176   }
26177
26178 }
26179
26180
26181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26182   int jresult ;
26183   int result;
26184
26185   result = (int)Dali::Shader::Property::PROGRAM;
26186   jresult = (int)result;
26187   return jresult;
26188 }
26189
26190
26191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26192   void * jresult ;
26193   Dali::Shader::Property *result = 0 ;
26194
26195   {
26196     try {
26197       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26198     } catch (std::out_of_range& e) {
26199       {
26200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26201       };
26202     } catch (std::exception& e) {
26203       {
26204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (Dali::DaliException e) {
26207       {
26208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26209       };
26210     } catch (...) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26213       };
26214     }
26215   }
26216
26217   jresult = (void *)result;
26218   return jresult;
26219 }
26220
26221
26222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26223   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26224
26225   arg1 = (Dali::Shader::Property *)jarg1;
26226   {
26227     try {
26228       delete arg1;
26229     } catch (std::out_of_range& e) {
26230       {
26231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26232       };
26233     } catch (std::exception& e) {
26234       {
26235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (Dali::DaliException e) {
26238       {
26239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26240       };
26241     } catch (...) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26244       };
26245     }
26246   }
26247
26248 }
26249
26250
26251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26252   void * jresult ;
26253   std::string *arg1 = 0 ;
26254   std::string *arg2 = 0 ;
26255   Dali::Shader::Hint::Value arg3 ;
26256   Dali::Shader result;
26257
26258   if (!jarg1) {
26259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26260     return 0;
26261   }
26262   std::string arg1_str(jarg1);
26263   arg1 = &arg1_str;
26264   if (!jarg2) {
26265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26266     return 0;
26267   }
26268   std::string arg2_str(jarg2);
26269   arg2 = &arg2_str;
26270   arg3 = (Dali::Shader::Hint::Value)jarg3;
26271   {
26272     try {
26273       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26274     } catch (std::out_of_range& e) {
26275       {
26276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (std::exception& e) {
26279       {
26280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (Dali::DaliException e) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26285       };
26286     } catch (...) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26289       };
26290     }
26291   }
26292
26293   jresult = new Dali::Shader((const Dali::Shader &)result);
26294
26295   //argout typemap for const std::string&
26296
26297
26298   //argout typemap for const std::string&
26299
26300   return jresult;
26301 }
26302
26303
26304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26305   void * jresult ;
26306   std::string *arg1 = 0 ;
26307   std::string *arg2 = 0 ;
26308   Dali::Shader result;
26309
26310   if (!jarg1) {
26311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26312     return 0;
26313   }
26314   std::string arg1_str(jarg1);
26315   arg1 = &arg1_str;
26316   if (!jarg2) {
26317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26318     return 0;
26319   }
26320   std::string arg2_str(jarg2);
26321   arg2 = &arg2_str;
26322   {
26323     try {
26324       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26325     } catch (std::out_of_range& e) {
26326       {
26327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26328       };
26329     } catch (std::exception& e) {
26330       {
26331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (Dali::DaliException e) {
26334       {
26335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26336       };
26337     } catch (...) {
26338       {
26339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26340       };
26341     }
26342   }
26343
26344   jresult = new Dali::Shader((const Dali::Shader &)result);
26345
26346   //argout typemap for const std::string&
26347
26348
26349   //argout typemap for const std::string&
26350
26351   return jresult;
26352 }
26353
26354
26355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26356   void * jresult ;
26357   Dali::Shader *result = 0 ;
26358
26359   {
26360     try {
26361       result = (Dali::Shader *)new Dali::Shader();
26362     } catch (std::out_of_range& e) {
26363       {
26364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26365       };
26366     } catch (std::exception& e) {
26367       {
26368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (Dali::DaliException e) {
26371       {
26372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26373       };
26374     } catch (...) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26377       };
26378     }
26379   }
26380
26381   jresult = (void *)result;
26382   return jresult;
26383 }
26384
26385
26386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26387   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26388
26389   arg1 = (Dali::Shader *)jarg1;
26390   {
26391     try {
26392       delete arg1;
26393     } catch (std::out_of_range& e) {
26394       {
26395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26396       };
26397     } catch (std::exception& e) {
26398       {
26399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26400       };
26401     } catch (Dali::DaliException e) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26404       };
26405     } catch (...) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26408       };
26409     }
26410   }
26411
26412 }
26413
26414
26415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26416   void * jresult ;
26417   Dali::Shader *arg1 = 0 ;
26418   Dali::Shader *result = 0 ;
26419
26420   arg1 = (Dali::Shader *)jarg1;
26421   if (!arg1) {
26422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26423     return 0;
26424   }
26425   {
26426     try {
26427       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26428     } catch (std::out_of_range& e) {
26429       {
26430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26431       };
26432     } catch (std::exception& e) {
26433       {
26434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (Dali::DaliException e) {
26437       {
26438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26439       };
26440     } catch (...) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26443       };
26444     }
26445   }
26446
26447   jresult = (void *)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26453   void * jresult ;
26454   Dali::BaseHandle arg1 ;
26455   Dali::BaseHandle *argp1 ;
26456   Dali::Shader result;
26457
26458   argp1 = (Dali::BaseHandle *)jarg1;
26459   if (!argp1) {
26460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26461     return 0;
26462   }
26463   arg1 = *argp1;
26464   {
26465     try {
26466       result = Dali::Shader::DownCast(arg1);
26467     } catch (std::out_of_range& e) {
26468       {
26469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26470       };
26471     } catch (std::exception& e) {
26472       {
26473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (Dali::DaliException e) {
26476       {
26477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26478       };
26479     } catch (...) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26482       };
26483     }
26484   }
26485
26486   jresult = new Dali::Shader((const Dali::Shader &)result);
26487   return jresult;
26488 }
26489
26490
26491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26492   void * jresult ;
26493   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26494   Dali::Shader *arg2 = 0 ;
26495   Dali::Shader *result = 0 ;
26496
26497   arg1 = (Dali::Shader *)jarg1;
26498   arg2 = (Dali::Shader *)jarg2;
26499   if (!arg2) {
26500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26501     return 0;
26502   }
26503   {
26504     try {
26505       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26506     } catch (std::out_of_range& e) {
26507       {
26508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26509       };
26510     } catch (std::exception& e) {
26511       {
26512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (Dali::DaliException e) {
26515       {
26516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26517       };
26518     } catch (...) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26521       };
26522     }
26523   }
26524
26525   jresult = (void *)result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26531   int jresult ;
26532   int result;
26533
26534   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26535   jresult = (int)result;
26536   return jresult;
26537 }
26538
26539
26540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26541   int jresult ;
26542   int result;
26543
26544   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26545   jresult = (int)result;
26546   return jresult;
26547 }
26548
26549
26550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26551   int jresult ;
26552   int result;
26553
26554   result = (int)Dali::Renderer::Property::BLEND_MODE;
26555   jresult = (int)result;
26556   return jresult;
26557 }
26558
26559
26560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26561   int jresult ;
26562   int result;
26563
26564   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26565   jresult = (int)result;
26566   return jresult;
26567 }
26568
26569
26570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26571   int jresult ;
26572   int result;
26573
26574   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26575   jresult = (int)result;
26576   return jresult;
26577 }
26578
26579
26580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26581   int jresult ;
26582   int result;
26583
26584   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26585   jresult = (int)result;
26586   return jresult;
26587 }
26588
26589
26590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26591   int jresult ;
26592   int result;
26593
26594   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26595   jresult = (int)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26601   int jresult ;
26602   int result;
26603
26604   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26605   jresult = (int)result;
26606   return jresult;
26607 }
26608
26609
26610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26611   int jresult ;
26612   int result;
26613
26614   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26615   jresult = (int)result;
26616   return jresult;
26617 }
26618
26619
26620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26621   int jresult ;
26622   int result;
26623
26624   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26625   jresult = (int)result;
26626   return jresult;
26627 }
26628
26629
26630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26631   int jresult ;
26632   int result;
26633
26634   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26635   jresult = (int)result;
26636   return jresult;
26637 }
26638
26639
26640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26641   int jresult ;
26642   int result;
26643
26644   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26645   jresult = (int)result;
26646   return jresult;
26647 }
26648
26649
26650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26651   int jresult ;
26652   int result;
26653
26654   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26655   jresult = (int)result;
26656   return jresult;
26657 }
26658
26659
26660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26661   int jresult ;
26662   int result;
26663
26664   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26665   jresult = (int)result;
26666   return jresult;
26667 }
26668
26669
26670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26671   int jresult ;
26672   int result;
26673
26674   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26675   jresult = (int)result;
26676   return jresult;
26677 }
26678
26679
26680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26681   int jresult ;
26682   int result;
26683
26684   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26685   jresult = (int)result;
26686   return jresult;
26687 }
26688
26689
26690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26691   int jresult ;
26692   int result;
26693
26694   result = (int)Dali::Renderer::Property::RENDER_MODE;
26695   jresult = (int)result;
26696   return jresult;
26697 }
26698
26699
26700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26701   int jresult ;
26702   int result;
26703
26704   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26705   jresult = (int)result;
26706   return jresult;
26707 }
26708
26709
26710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26711   int jresult ;
26712   int result;
26713
26714   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26715   jresult = (int)result;
26716   return jresult;
26717 }
26718
26719
26720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26721   int jresult ;
26722   int result;
26723
26724   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26725   jresult = (int)result;
26726   return jresult;
26727 }
26728
26729
26730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26731   int jresult ;
26732   int result;
26733
26734   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26735   jresult = (int)result;
26736   return jresult;
26737 }
26738
26739
26740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26741   int jresult ;
26742   int result;
26743
26744   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26745   jresult = (int)result;
26746   return jresult;
26747 }
26748
26749
26750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26751   int jresult ;
26752   int result;
26753
26754   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26755   jresult = (int)result;
26756   return jresult;
26757 }
26758
26759
26760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26761   int jresult ;
26762   int result;
26763
26764   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26765   jresult = (int)result;
26766   return jresult;
26767 }
26768
26769
26770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26771   void * jresult ;
26772   Dali::Renderer::Property *result = 0 ;
26773
26774   {
26775     try {
26776       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26777     } catch (std::out_of_range& e) {
26778       {
26779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26780       };
26781     } catch (std::exception& e) {
26782       {
26783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26784       };
26785     } catch (Dali::DaliException e) {
26786       {
26787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26788       };
26789     } catch (...) {
26790       {
26791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26792       };
26793     }
26794   }
26795
26796   jresult = (void *)result;
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26802   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26803
26804   arg1 = (Dali::Renderer::Property *)jarg1;
26805   {
26806     try {
26807       delete arg1;
26808     } catch (std::out_of_range& e) {
26809       {
26810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26811       };
26812     } catch (std::exception& e) {
26813       {
26814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26815       };
26816     } catch (Dali::DaliException e) {
26817       {
26818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26819       };
26820     } catch (...) {
26821       {
26822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26823       };
26824     }
26825   }
26826
26827 }
26828
26829
26830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26831   void * jresult ;
26832   Dali::Geometry *arg1 = 0 ;
26833   Dali::Shader *arg2 = 0 ;
26834   Dali::Renderer result;
26835
26836   arg1 = (Dali::Geometry *)jarg1;
26837   if (!arg1) {
26838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26839     return 0;
26840   }
26841   arg2 = (Dali::Shader *)jarg2;
26842   if (!arg2) {
26843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26844     return 0;
26845   }
26846   {
26847     try {
26848       result = Dali::Renderer::New(*arg1,*arg2);
26849     } catch (std::out_of_range& e) {
26850       {
26851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26852       };
26853     } catch (std::exception& e) {
26854       {
26855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26856       };
26857     } catch (Dali::DaliException e) {
26858       {
26859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26860       };
26861     } catch (...) {
26862       {
26863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26864       };
26865     }
26866   }
26867
26868   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26869   return jresult;
26870 }
26871
26872
26873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26874   void * jresult ;
26875   Dali::Renderer *result = 0 ;
26876
26877   {
26878     try {
26879       result = (Dali::Renderer *)new Dali::Renderer();
26880     } catch (std::out_of_range& e) {
26881       {
26882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26883       };
26884     } catch (std::exception& e) {
26885       {
26886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26887       };
26888     } catch (Dali::DaliException e) {
26889       {
26890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26891       };
26892     } catch (...) {
26893       {
26894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26895       };
26896     }
26897   }
26898
26899   jresult = (void *)result;
26900   return jresult;
26901 }
26902
26903
26904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26905   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26906
26907   arg1 = (Dali::Renderer *)jarg1;
26908   {
26909     try {
26910       delete arg1;
26911     } catch (std::out_of_range& e) {
26912       {
26913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26914       };
26915     } catch (std::exception& e) {
26916       {
26917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26918       };
26919     } catch (Dali::DaliException e) {
26920       {
26921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26922       };
26923     } catch (...) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26926       };
26927     }
26928   }
26929
26930 }
26931
26932
26933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26934   void * jresult ;
26935   Dali::Renderer *arg1 = 0 ;
26936   Dali::Renderer *result = 0 ;
26937
26938   arg1 = (Dali::Renderer *)jarg1;
26939   if (!arg1) {
26940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26941     return 0;
26942   }
26943   {
26944     try {
26945       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26946     } catch (std::out_of_range& e) {
26947       {
26948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26949       };
26950     } catch (std::exception& e) {
26951       {
26952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26953       };
26954     } catch (Dali::DaliException e) {
26955       {
26956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26957       };
26958     } catch (...) {
26959       {
26960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26961       };
26962     }
26963   }
26964
26965   jresult = (void *)result;
26966   return jresult;
26967 }
26968
26969
26970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26971   void * jresult ;
26972   Dali::BaseHandle arg1 ;
26973   Dali::BaseHandle *argp1 ;
26974   Dali::Renderer result;
26975
26976   argp1 = (Dali::BaseHandle *)jarg1;
26977   if (!argp1) {
26978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26979     return 0;
26980   }
26981   arg1 = *argp1;
26982   {
26983     try {
26984       result = Dali::Renderer::DownCast(arg1);
26985     } catch (std::out_of_range& e) {
26986       {
26987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26988       };
26989     } catch (std::exception& e) {
26990       {
26991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26992       };
26993     } catch (Dali::DaliException e) {
26994       {
26995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26996       };
26997     } catch (...) {
26998       {
26999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27000       };
27001     }
27002   }
27003
27004   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27005   return jresult;
27006 }
27007
27008
27009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27010   void * jresult ;
27011   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27012   Dali::Renderer *arg2 = 0 ;
27013   Dali::Renderer *result = 0 ;
27014
27015   arg1 = (Dali::Renderer *)jarg1;
27016   arg2 = (Dali::Renderer *)jarg2;
27017   if (!arg2) {
27018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27019     return 0;
27020   }
27021   {
27022     try {
27023       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27024     } catch (std::out_of_range& e) {
27025       {
27026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (std::exception& e) {
27029       {
27030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27031       };
27032     } catch (Dali::DaliException e) {
27033       {
27034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27035       };
27036     } catch (...) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27039       };
27040     }
27041   }
27042
27043   jresult = (void *)result;
27044   return jresult;
27045 }
27046
27047
27048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27049   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27050   Dali::Geometry *arg2 = 0 ;
27051
27052   arg1 = (Dali::Renderer *)jarg1;
27053   arg2 = (Dali::Geometry *)jarg2;
27054   if (!arg2) {
27055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27056     return ;
27057   }
27058   {
27059     try {
27060       (arg1)->SetGeometry(*arg2);
27061     } catch (std::out_of_range& e) {
27062       {
27063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27064       };
27065     } catch (std::exception& e) {
27066       {
27067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27068       };
27069     } catch (Dali::DaliException e) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27072       };
27073     } catch (...) {
27074       {
27075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27076       };
27077     }
27078   }
27079
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27084   void * jresult ;
27085   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27086   Dali::Geometry result;
27087
27088   arg1 = (Dali::Renderer *)jarg1;
27089   {
27090     try {
27091       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (Dali::DaliException e) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27103       };
27104     } catch (...) {
27105       {
27106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27107       };
27108     }
27109   }
27110
27111   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27112   return jresult;
27113 }
27114
27115
27116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27117   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27118   int arg2 ;
27119   int arg3 ;
27120
27121   arg1 = (Dali::Renderer *)jarg1;
27122   arg2 = (int)jarg2;
27123   arg3 = (int)jarg3;
27124   {
27125     try {
27126       (arg1)->SetIndexRange(arg2,arg3);
27127     } catch (std::out_of_range& e) {
27128       {
27129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27130       };
27131     } catch (std::exception& e) {
27132       {
27133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27134       };
27135     } catch (Dali::DaliException e) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27138       };
27139     } catch (...) {
27140       {
27141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27142       };
27143     }
27144   }
27145
27146 }
27147
27148
27149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27150   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27151   Dali::TextureSet *arg2 = 0 ;
27152
27153   arg1 = (Dali::Renderer *)jarg1;
27154   arg2 = (Dali::TextureSet *)jarg2;
27155   if (!arg2) {
27156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27157     return ;
27158   }
27159   {
27160     try {
27161       (arg1)->SetTextures(*arg2);
27162     } catch (std::out_of_range& e) {
27163       {
27164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27165       };
27166     } catch (std::exception& e) {
27167       {
27168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27169       };
27170     } catch (Dali::DaliException e) {
27171       {
27172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27173       };
27174     } catch (...) {
27175       {
27176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27177       };
27178     }
27179   }
27180
27181 }
27182
27183
27184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27185   void * jresult ;
27186   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27187   Dali::TextureSet result;
27188
27189   arg1 = (Dali::Renderer *)jarg1;
27190   {
27191     try {
27192       result = ((Dali::Renderer const *)arg1)->GetTextures();
27193     } catch (std::out_of_range& e) {
27194       {
27195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (std::exception& e) {
27198       {
27199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27200       };
27201     } catch (Dali::DaliException e) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27204       };
27205     } catch (...) {
27206       {
27207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27208       };
27209     }
27210   }
27211
27212   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27213   return jresult;
27214 }
27215
27216
27217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27218   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27219   Dali::Shader *arg2 = 0 ;
27220
27221   arg1 = (Dali::Renderer *)jarg1;
27222   arg2 = (Dali::Shader *)jarg2;
27223   if (!arg2) {
27224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27225     return ;
27226   }
27227   {
27228     try {
27229       (arg1)->SetShader(*arg2);
27230     } catch (std::out_of_range& e) {
27231       {
27232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27233       };
27234     } catch (std::exception& e) {
27235       {
27236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27237       };
27238     } catch (Dali::DaliException e) {
27239       {
27240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27241       };
27242     } catch (...) {
27243       {
27244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27245       };
27246     }
27247   }
27248
27249 }
27250
27251
27252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27253   void * jresult ;
27254   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27255   Dali::Shader result;
27256
27257   arg1 = (Dali::Renderer *)jarg1;
27258   {
27259     try {
27260       result = ((Dali::Renderer const *)arg1)->GetShader();
27261     } catch (std::out_of_range& e) {
27262       {
27263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (std::exception& e) {
27266       {
27267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27268       };
27269     } catch (Dali::DaliException e) {
27270       {
27271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27272       };
27273     } catch (...) {
27274       {
27275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27276       };
27277     }
27278   }
27279
27280   jresult = new Dali::Shader((const Dali::Shader &)result);
27281   return jresult;
27282 }
27283
27284
27285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27286   void * jresult ;
27287   Dali::FrameBuffer::Attachment *result = 0 ;
27288
27289   {
27290     try {
27291       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27292     } catch (std::out_of_range& e) {
27293       {
27294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27295       };
27296     } catch (std::exception& e) {
27297       {
27298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27299       };
27300     } catch (Dali::DaliException e) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27303       };
27304     } catch (...) {
27305       {
27306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27307       };
27308     }
27309   }
27310
27311   jresult = (void *)result;
27312   return jresult;
27313 }
27314
27315
27316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27317   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27318
27319   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27320   {
27321     try {
27322       delete arg1;
27323     } catch (std::out_of_range& e) {
27324       {
27325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27326       };
27327     } catch (std::exception& e) {
27328       {
27329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27330       };
27331     } catch (Dali::DaliException e) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27334       };
27335     } catch (...) {
27336       {
27337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27338       };
27339     }
27340   }
27341
27342 }
27343
27344
27345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27346   void * jresult ;
27347   unsigned int arg1 ;
27348   unsigned int arg2 ;
27349   unsigned int arg3 ;
27350   Dali::FrameBuffer result;
27351
27352   arg1 = (unsigned int)jarg1;
27353   arg2 = (unsigned int)jarg2;
27354   arg3 = (unsigned int)jarg3;
27355   {
27356     try {
27357       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27358     } catch (std::out_of_range& e) {
27359       {
27360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27361       };
27362     } catch (std::exception& e) {
27363       {
27364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27365       };
27366     } catch (Dali::DaliException e) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27369       };
27370     } catch (...) {
27371       {
27372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27373       };
27374     }
27375   }
27376
27377   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27378   return jresult;
27379 }
27380
27381
27382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27383   void * jresult ;
27384   Dali::FrameBuffer *result = 0 ;
27385
27386   {
27387     try {
27388       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27389     } catch (std::out_of_range& e) {
27390       {
27391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27392       };
27393     } catch (std::exception& e) {
27394       {
27395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27396       };
27397     } catch (Dali::DaliException e) {
27398       {
27399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27400       };
27401     } catch (...) {
27402       {
27403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27404       };
27405     }
27406   }
27407
27408   jresult = (void *)result;
27409   return jresult;
27410 }
27411
27412
27413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27414   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27415
27416   arg1 = (Dali::FrameBuffer *)jarg1;
27417   {
27418     try {
27419       delete arg1;
27420     } catch (std::out_of_range& e) {
27421       {
27422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27423       };
27424     } catch (std::exception& e) {
27425       {
27426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27427       };
27428     } catch (Dali::DaliException e) {
27429       {
27430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27431       };
27432     } catch (...) {
27433       {
27434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27435       };
27436     }
27437   }
27438
27439 }
27440
27441
27442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27443   void * jresult ;
27444   Dali::FrameBuffer *arg1 = 0 ;
27445   Dali::FrameBuffer *result = 0 ;
27446
27447   arg1 = (Dali::FrameBuffer *)jarg1;
27448   if (!arg1) {
27449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27450     return 0;
27451   }
27452   {
27453     try {
27454       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27455     } catch (std::out_of_range& e) {
27456       {
27457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27458       };
27459     } catch (std::exception& e) {
27460       {
27461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27462       };
27463     } catch (Dali::DaliException e) {
27464       {
27465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27466       };
27467     } catch (...) {
27468       {
27469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27470       };
27471     }
27472   }
27473
27474   jresult = (void *)result;
27475   return jresult;
27476 }
27477
27478
27479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27480   void * jresult ;
27481   Dali::BaseHandle arg1 ;
27482   Dali::BaseHandle *argp1 ;
27483   Dali::FrameBuffer result;
27484
27485   argp1 = (Dali::BaseHandle *)jarg1;
27486   if (!argp1) {
27487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27488     return 0;
27489   }
27490   arg1 = *argp1;
27491   {
27492     try {
27493       result = Dali::FrameBuffer::DownCast(arg1);
27494     } catch (std::out_of_range& e) {
27495       {
27496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27497       };
27498     } catch (std::exception& e) {
27499       {
27500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27501       };
27502     } catch (Dali::DaliException e) {
27503       {
27504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27505       };
27506     } catch (...) {
27507       {
27508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27509       };
27510     }
27511   }
27512
27513   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27514   return jresult;
27515 }
27516
27517
27518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27519   void * jresult ;
27520   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27521   Dali::FrameBuffer *arg2 = 0 ;
27522   Dali::FrameBuffer *result = 0 ;
27523
27524   arg1 = (Dali::FrameBuffer *)jarg1;
27525   arg2 = (Dali::FrameBuffer *)jarg2;
27526   if (!arg2) {
27527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27528     return 0;
27529   }
27530   {
27531     try {
27532       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27533     } catch (std::out_of_range& e) {
27534       {
27535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27536       };
27537     } catch (std::exception& e) {
27538       {
27539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27540       };
27541     } catch (Dali::DaliException e) {
27542       {
27543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27544       };
27545     } catch (...) {
27546       {
27547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27548       };
27549     }
27550   }
27551
27552   jresult = (void *)result;
27553   return jresult;
27554 }
27555
27556
27557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27558   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27559   Dali::Texture *arg2 = 0 ;
27560
27561   arg1 = (Dali::FrameBuffer *)jarg1;
27562   arg2 = (Dali::Texture *)jarg2;
27563   if (!arg2) {
27564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27565     return ;
27566   }
27567   {
27568     try {
27569       (arg1)->AttachColorTexture(*arg2);
27570     } catch (std::out_of_range& e) {
27571       {
27572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27573       };
27574     } catch (std::exception& e) {
27575       {
27576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27577       };
27578     } catch (Dali::DaliException e) {
27579       {
27580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27581       };
27582     } catch (...) {
27583       {
27584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27585       };
27586     }
27587   }
27588
27589 }
27590
27591
27592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27593   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27594   Dali::Texture *arg2 = 0 ;
27595   unsigned int arg3 ;
27596   unsigned int arg4 ;
27597
27598   arg1 = (Dali::FrameBuffer *)jarg1;
27599   arg2 = (Dali::Texture *)jarg2;
27600   if (!arg2) {
27601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27602     return ;
27603   }
27604   arg3 = (unsigned int)jarg3;
27605   arg4 = (unsigned int)jarg4;
27606   {
27607     try {
27608       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27609     } catch (std::out_of_range& e) {
27610       {
27611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27612       };
27613     } catch (std::exception& e) {
27614       {
27615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27616       };
27617     } catch (Dali::DaliException e) {
27618       {
27619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27620       };
27621     } catch (...) {
27622       {
27623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27624       };
27625     }
27626   }
27627
27628 }
27629
27630
27631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27632   void * jresult ;
27633   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27634   Dali::Texture result;
27635
27636   arg1 = (Dali::FrameBuffer *)jarg1;
27637   {
27638     try {
27639       result = (arg1)->GetColorTexture();
27640     } catch (std::out_of_range& e) {
27641       {
27642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27643       };
27644     } catch (std::exception& e) {
27645       {
27646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27647       };
27648     } catch (Dali::DaliException e) {
27649       {
27650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27651       };
27652     } catch (...) {
27653       {
27654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27655       };
27656     }
27657   }
27658
27659   jresult = new Dali::Texture((const Dali::Texture &)result);
27660   return jresult;
27661 }
27662
27663
27664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27665   void * jresult ;
27666   Dali::RenderTaskList *result = 0 ;
27667
27668   {
27669     try {
27670       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27671     } catch (std::out_of_range& e) {
27672       {
27673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27674       };
27675     } catch (std::exception& e) {
27676       {
27677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27678       };
27679     } catch (Dali::DaliException e) {
27680       {
27681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27686       };
27687     }
27688   }
27689
27690   jresult = (void *)result;
27691   return jresult;
27692 }
27693
27694
27695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27696   void * jresult ;
27697   Dali::BaseHandle arg1 ;
27698   Dali::BaseHandle *argp1 ;
27699   Dali::RenderTaskList result;
27700
27701   argp1 = (Dali::BaseHandle *)jarg1;
27702   if (!argp1) {
27703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27704     return 0;
27705   }
27706   arg1 = *argp1;
27707   {
27708     try {
27709       result = Dali::RenderTaskList::DownCast(arg1);
27710     } catch (std::out_of_range& e) {
27711       {
27712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27713       };
27714     } catch (std::exception& e) {
27715       {
27716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27717       };
27718     } catch (Dali::DaliException e) {
27719       {
27720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27721       };
27722     } catch (...) {
27723       {
27724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27725       };
27726     }
27727   }
27728
27729   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27730   return jresult;
27731 }
27732
27733
27734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27735   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27736
27737   arg1 = (Dali::RenderTaskList *)jarg1;
27738   {
27739     try {
27740       delete arg1;
27741     } catch (std::out_of_range& e) {
27742       {
27743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27744       };
27745     } catch (std::exception& e) {
27746       {
27747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27748       };
27749     } catch (Dali::DaliException e) {
27750       {
27751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27752       };
27753     } catch (...) {
27754       {
27755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27756       };
27757     }
27758   }
27759
27760 }
27761
27762
27763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27764   void * jresult ;
27765   Dali::RenderTaskList *arg1 = 0 ;
27766   Dali::RenderTaskList *result = 0 ;
27767
27768   arg1 = (Dali::RenderTaskList *)jarg1;
27769   if (!arg1) {
27770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27771     return 0;
27772   }
27773   {
27774     try {
27775       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27776     } catch (std::out_of_range& e) {
27777       {
27778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27779       };
27780     } catch (std::exception& e) {
27781       {
27782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27783       };
27784     } catch (Dali::DaliException e) {
27785       {
27786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27787       };
27788     } catch (...) {
27789       {
27790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27791       };
27792     }
27793   }
27794
27795   jresult = (void *)result;
27796   return jresult;
27797 }
27798
27799
27800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27801   void * jresult ;
27802   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27803   Dali::RenderTaskList *arg2 = 0 ;
27804   Dali::RenderTaskList *result = 0 ;
27805
27806   arg1 = (Dali::RenderTaskList *)jarg1;
27807   arg2 = (Dali::RenderTaskList *)jarg2;
27808   if (!arg2) {
27809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27810     return 0;
27811   }
27812   {
27813     try {
27814       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27815     } catch (std::out_of_range& e) {
27816       {
27817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27818       };
27819     } catch (std::exception& e) {
27820       {
27821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27822       };
27823     } catch (Dali::DaliException e) {
27824       {
27825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27826       };
27827     } catch (...) {
27828       {
27829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27830       };
27831     }
27832   }
27833
27834   jresult = (void *)result;
27835   return jresult;
27836 }
27837
27838
27839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27840   void * jresult ;
27841   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27842   Dali::RenderTask result;
27843
27844   arg1 = (Dali::RenderTaskList *)jarg1;
27845   {
27846     try {
27847       result = (arg1)->CreateTask();
27848     } catch (std::out_of_range& e) {
27849       {
27850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27851       };
27852     } catch (std::exception& e) {
27853       {
27854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27855       };
27856     } catch (Dali::DaliException e) {
27857       {
27858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27859       };
27860     } catch (...) {
27861       {
27862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27863       };
27864     }
27865   }
27866
27867   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27868   return jresult;
27869 }
27870
27871
27872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27873   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27874   Dali::RenderTask arg2 ;
27875   Dali::RenderTask *argp2 ;
27876
27877   arg1 = (Dali::RenderTaskList *)jarg1;
27878   argp2 = (Dali::RenderTask *)jarg2;
27879   if (!argp2) {
27880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27881     return ;
27882   }
27883   arg2 = *argp2;
27884   {
27885     try {
27886       (arg1)->RemoveTask(arg2);
27887     } catch (std::out_of_range& e) {
27888       {
27889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27890       };
27891     } catch (std::exception& e) {
27892       {
27893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27894       };
27895     } catch (Dali::DaliException e) {
27896       {
27897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27898       };
27899     } catch (...) {
27900       {
27901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27902       };
27903     }
27904   }
27905
27906 }
27907
27908
27909 //// ===============================================end part 1 =================
27910
27911 //// ========================= part 2 ===============================
27912
27913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27914   unsigned int jresult ;
27915   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27916   unsigned int result;
27917
27918   arg1 = (Dali::RenderTaskList *)jarg1;
27919   {
27920     try {
27921       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27922     } catch (std::out_of_range& e) {
27923       {
27924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27925       };
27926     } catch (std::exception& e) {
27927       {
27928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27929       };
27930     } catch (Dali::DaliException e) {
27931       {
27932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27933       };
27934     } catch (...) {
27935       {
27936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27937       };
27938     }
27939   }
27940
27941   jresult = result;
27942   return jresult;
27943 }
27944
27945
27946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27947   void * jresult ;
27948   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27949   unsigned int arg2 ;
27950   Dali::RenderTask result;
27951
27952   arg1 = (Dali::RenderTaskList *)jarg1;
27953   arg2 = (unsigned int)jarg2;
27954   {
27955     try {
27956       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (Dali::DaliException e) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27968       };
27969     } catch (...) {
27970       {
27971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27972       };
27973     }
27974   }
27975
27976   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27977   return jresult;
27978 }
27979
27980
27981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27982   int jresult ;
27983   int result;
27984
27985   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27986   jresult = (int)result;
27987   return jresult;
27988 }
27989
27990
27991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27992   int jresult ;
27993   int result;
27994
27995   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27996   jresult = (int)result;
27997   return jresult;
27998 }
27999
28000
28001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28002   int jresult ;
28003   int result;
28004
28005   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28006   jresult = (int)result;
28007   return jresult;
28008 }
28009
28010
28011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28012   int jresult ;
28013   int result;
28014
28015   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28016   jresult = (int)result;
28017   return jresult;
28018 }
28019
28020
28021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28022   void * jresult ;
28023   Dali::RenderTask::Property *result = 0 ;
28024
28025   {
28026     try {
28027       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28028     } catch (std::out_of_range& e) {
28029       {
28030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28031       };
28032     } catch (std::exception& e) {
28033       {
28034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28035       };
28036     } catch (Dali::DaliException e) {
28037       {
28038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28039       };
28040     } catch (...) {
28041       {
28042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28043       };
28044     }
28045   }
28046
28047   jresult = (void *)result;
28048   return jresult;
28049 }
28050
28051
28052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28053   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28054
28055   arg1 = (Dali::RenderTask::Property *)jarg1;
28056   {
28057     try {
28058       delete arg1;
28059     } catch (std::out_of_range& e) {
28060       {
28061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28062       };
28063     } catch (std::exception& e) {
28064       {
28065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28066       };
28067     } catch (Dali::DaliException e) {
28068       {
28069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28070       };
28071     } catch (...) {
28072       {
28073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28074       };
28075     }
28076   }
28077
28078 }
28079
28080
28081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28082   void * jresult ;
28083   bool (*result)(Dali::Vector2 &) = 0 ;
28084
28085   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28086   jresult = (void *)result;
28087   return jresult;
28088 }
28089
28090
28091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28092   void * jresult ;
28093   bool (*result)(Dali::Vector2 &) = 0 ;
28094
28095   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28096   jresult = (void *)result;
28097   return jresult;
28098 }
28099
28100
28101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28102   unsigned int jresult ;
28103   bool result;
28104
28105   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28106   jresult = result;
28107   return jresult;
28108 }
28109
28110
28111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28112   unsigned int jresult ;
28113   bool result;
28114
28115   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28116   jresult = result;
28117   return jresult;
28118 }
28119
28120
28121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28122   void * jresult ;
28123   Dali::Vector4 *result = 0 ;
28124
28125   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28126   jresult = (void *)result;
28127   return jresult;
28128 }
28129
28130
28131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28132   unsigned int jresult ;
28133   bool result;
28134
28135   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28136   jresult = result;
28137   return jresult;
28138 }
28139
28140
28141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28142   unsigned int jresult ;
28143   bool result;
28144
28145   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28146   jresult = result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28152   unsigned int jresult ;
28153   unsigned int result;
28154
28155   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28156   jresult = result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28162   void * jresult ;
28163   Dali::RenderTask *result = 0 ;
28164
28165   {
28166     try {
28167       result = (Dali::RenderTask *)new Dali::RenderTask();
28168     } catch (std::out_of_range& e) {
28169       {
28170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28171       };
28172     } catch (std::exception& e) {
28173       {
28174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28175       };
28176     } catch (Dali::DaliException e) {
28177       {
28178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28179       };
28180     } catch (...) {
28181       {
28182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28183       };
28184     }
28185   }
28186
28187   jresult = (void *)result;
28188   return jresult;
28189 }
28190
28191
28192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28193   void * jresult ;
28194   Dali::BaseHandle arg1 ;
28195   Dali::BaseHandle *argp1 ;
28196   Dali::RenderTask result;
28197
28198   argp1 = (Dali::BaseHandle *)jarg1;
28199   if (!argp1) {
28200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28201     return 0;
28202   }
28203   arg1 = *argp1;
28204   {
28205     try {
28206       result = Dali::RenderTask::DownCast(arg1);
28207     } catch (std::out_of_range& e) {
28208       {
28209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28210       };
28211     } catch (std::exception& e) {
28212       {
28213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28214       };
28215     } catch (Dali::DaliException e) {
28216       {
28217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28218       };
28219     } catch (...) {
28220       {
28221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28222       };
28223     }
28224   }
28225
28226   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28227   return jresult;
28228 }
28229
28230
28231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28232   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28233
28234   arg1 = (Dali::RenderTask *)jarg1;
28235   {
28236     try {
28237       delete arg1;
28238     } catch (std::out_of_range& e) {
28239       {
28240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28241       };
28242     } catch (std::exception& e) {
28243       {
28244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28245       };
28246     } catch (Dali::DaliException e) {
28247       {
28248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28249       };
28250     } catch (...) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28253       };
28254     }
28255   }
28256
28257 }
28258
28259
28260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28261   void * jresult ;
28262   Dali::RenderTask *arg1 = 0 ;
28263   Dali::RenderTask *result = 0 ;
28264
28265   arg1 = (Dali::RenderTask *)jarg1;
28266   if (!arg1) {
28267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28268     return 0;
28269   }
28270   {
28271     try {
28272       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28273     } catch (std::out_of_range& e) {
28274       {
28275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28276       };
28277     } catch (std::exception& e) {
28278       {
28279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28280       };
28281     } catch (Dali::DaliException e) {
28282       {
28283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28284       };
28285     } catch (...) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28288       };
28289     }
28290   }
28291
28292   jresult = (void *)result;
28293   return jresult;
28294 }
28295
28296
28297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28298   void * jresult ;
28299   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28300   Dali::RenderTask *arg2 = 0 ;
28301   Dali::RenderTask *result = 0 ;
28302
28303   arg1 = (Dali::RenderTask *)jarg1;
28304   arg2 = (Dali::RenderTask *)jarg2;
28305   if (!arg2) {
28306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28307     return 0;
28308   }
28309   {
28310     try {
28311       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28312     } catch (std::out_of_range& e) {
28313       {
28314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (std::exception& e) {
28317       {
28318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28319       };
28320     } catch (Dali::DaliException e) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28323       };
28324     } catch (...) {
28325       {
28326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28327       };
28328     }
28329   }
28330
28331   jresult = (void *)result;
28332   return jresult;
28333 }
28334
28335
28336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28337   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28338   Dali::Actor arg2 ;
28339   Dali::Actor *argp2 ;
28340
28341   arg1 = (Dali::RenderTask *)jarg1;
28342   argp2 = (Dali::Actor *)jarg2;
28343   if (!argp2) {
28344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28345     return ;
28346   }
28347   arg2 = *argp2;
28348   {
28349     try {
28350       (arg1)->SetSourceActor(arg2);
28351     } catch (std::out_of_range& e) {
28352       {
28353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28354       };
28355     } catch (std::exception& e) {
28356       {
28357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28358       };
28359     } catch (Dali::DaliException e) {
28360       {
28361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28362       };
28363     } catch (...) {
28364       {
28365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28366       };
28367     }
28368   }
28369
28370 }
28371
28372
28373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28374   void * jresult ;
28375   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28376   Dali::Actor result;
28377
28378   arg1 = (Dali::RenderTask *)jarg1;
28379   {
28380     try {
28381       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28382     } catch (std::out_of_range& e) {
28383       {
28384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28385       };
28386     } catch (std::exception& e) {
28387       {
28388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28389       };
28390     } catch (Dali::DaliException e) {
28391       {
28392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28393       };
28394     } catch (...) {
28395       {
28396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28397       };
28398     }
28399   }
28400
28401   jresult = new Dali::Actor((const Dali::Actor &)result);
28402   return jresult;
28403 }
28404
28405
28406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28407   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28408   bool arg2 ;
28409
28410   arg1 = (Dali::RenderTask *)jarg1;
28411   arg2 = jarg2 ? true : false;
28412   {
28413     try {
28414       (arg1)->SetExclusive(arg2);
28415     } catch (std::out_of_range& e) {
28416       {
28417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28418       };
28419     } catch (std::exception& e) {
28420       {
28421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28422       };
28423     } catch (Dali::DaliException e) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28426       };
28427     } catch (...) {
28428       {
28429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28430       };
28431     }
28432   }
28433
28434 }
28435
28436
28437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28438   unsigned int jresult ;
28439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28440   bool result;
28441
28442   arg1 = (Dali::RenderTask *)jarg1;
28443   {
28444     try {
28445       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28446     } catch (std::out_of_range& e) {
28447       {
28448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28449       };
28450     } catch (std::exception& e) {
28451       {
28452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28453       };
28454     } catch (Dali::DaliException e) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28457       };
28458     } catch (...) {
28459       {
28460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28461       };
28462     }
28463   }
28464
28465   jresult = result;
28466   return jresult;
28467 }
28468
28469
28470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28471   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28472   bool arg2 ;
28473
28474   arg1 = (Dali::RenderTask *)jarg1;
28475   arg2 = jarg2 ? true : false;
28476   {
28477     try {
28478       (arg1)->SetInputEnabled(arg2);
28479     } catch (std::out_of_range& e) {
28480       {
28481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (std::exception& e) {
28484       {
28485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28486       };
28487     } catch (Dali::DaliException e) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28490       };
28491     } catch (...) {
28492       {
28493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28494       };
28495     }
28496   }
28497
28498 }
28499
28500
28501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28502   unsigned int jresult ;
28503   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28504   bool result;
28505
28506   arg1 = (Dali::RenderTask *)jarg1;
28507   {
28508     try {
28509       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28510     } catch (std::out_of_range& e) {
28511       {
28512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (std::exception& e) {
28515       {
28516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28517       };
28518     } catch (Dali::DaliException e) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28521       };
28522     } catch (...) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28525       };
28526     }
28527   }
28528
28529   jresult = result;
28530   return jresult;
28531 }
28532
28533
28534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28535   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28536   Dali::CameraActor arg2 ;
28537   Dali::CameraActor *argp2 ;
28538
28539   arg1 = (Dali::RenderTask *)jarg1;
28540   argp2 = (Dali::CameraActor *)jarg2;
28541   if (!argp2) {
28542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28543     return ;
28544   }
28545   arg2 = *argp2;
28546   {
28547     try {
28548       (arg1)->SetCameraActor(arg2);
28549     } catch (std::out_of_range& e) {
28550       {
28551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (std::exception& e) {
28554       {
28555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28556       };
28557     } catch (Dali::DaliException e) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28560       };
28561     } catch (...) {
28562       {
28563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28564       };
28565     }
28566   }
28567
28568 }
28569
28570
28571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28572   void * jresult ;
28573   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28574   Dali::CameraActor result;
28575
28576   arg1 = (Dali::RenderTask *)jarg1;
28577   {
28578     try {
28579       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28580     } catch (std::out_of_range& e) {
28581       {
28582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28583       };
28584     } catch (std::exception& e) {
28585       {
28586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28587       };
28588     } catch (Dali::DaliException e) {
28589       {
28590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28591       };
28592     } catch (...) {
28593       {
28594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28595       };
28596     }
28597   }
28598
28599   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28600   return jresult;
28601 }
28602
28603
28604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28605   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28606   Dali::FrameBufferImage arg2 ;
28607   Dali::FrameBufferImage *argp2 ;
28608
28609   arg1 = (Dali::RenderTask *)jarg1;
28610   argp2 = (Dali::FrameBufferImage *)jarg2;
28611   if (!argp2) {
28612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28613     return ;
28614   }
28615   arg2 = *argp2;
28616   {
28617     try {
28618       (arg1)->SetTargetFrameBuffer(arg2);
28619     } catch (std::out_of_range& e) {
28620       {
28621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28622       };
28623     } catch (std::exception& e) {
28624       {
28625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28626       };
28627     } catch (Dali::DaliException e) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28630       };
28631     } catch (...) {
28632       {
28633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28634       };
28635     }
28636   }
28637
28638 }
28639
28640
28641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28642   void * jresult ;
28643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28644   Dali::FrameBufferImage result;
28645
28646   arg1 = (Dali::RenderTask *)jarg1;
28647   {
28648     try {
28649       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28650     } catch (std::out_of_range& e) {
28651       {
28652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28653       };
28654     } catch (std::exception& e) {
28655       {
28656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28657       };
28658     } catch (Dali::DaliException e) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28661       };
28662     } catch (...) {
28663       {
28664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28665       };
28666     }
28667   }
28668
28669   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28670   return jresult;
28671 }
28672
28673
28674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28675   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28676   Dali::FrameBuffer arg2 ;
28677   Dali::FrameBuffer *argp2 ;
28678
28679   arg1 = (Dali::RenderTask *)jarg1;
28680   argp2 = (Dali::FrameBuffer *)jarg2;
28681   if (!argp2) {
28682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28683     return ;
28684   }
28685   arg2 = *argp2;
28686   {
28687     try {
28688       (arg1)->SetFrameBuffer(arg2);
28689     } catch (std::out_of_range& e) {
28690       {
28691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28692       };
28693     } catch (std::exception& e) {
28694       {
28695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28696       };
28697     } catch (Dali::DaliException e) {
28698       {
28699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28700       };
28701     } catch (...) {
28702       {
28703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28704       };
28705     }
28706   }
28707
28708 }
28709
28710
28711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28712   void * jresult ;
28713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28714   Dali::FrameBuffer result;
28715
28716   arg1 = (Dali::RenderTask *)jarg1;
28717   {
28718     try {
28719       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28720     } catch (std::out_of_range& e) {
28721       {
28722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28723       };
28724     } catch (std::exception& e) {
28725       {
28726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28727       };
28728     } catch (Dali::DaliException e) {
28729       {
28730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28731       };
28732     } catch (...) {
28733       {
28734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28735       };
28736     }
28737   }
28738
28739   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28745   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28746   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28747
28748   arg1 = (Dali::RenderTask *)jarg1;
28749   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28750   {
28751     try {
28752       (arg1)->SetScreenToFrameBufferFunction(arg2);
28753     } catch (std::out_of_range& e) {
28754       {
28755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28756       };
28757     } catch (std::exception& e) {
28758       {
28759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28760       };
28761     } catch (Dali::DaliException e) {
28762       {
28763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28764       };
28765     } catch (...) {
28766       {
28767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28768       };
28769     }
28770   }
28771
28772 }
28773
28774
28775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28776   void * jresult ;
28777   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28778   Dali::RenderTask::ScreenToFrameBufferFunction result;
28779
28780   arg1 = (Dali::RenderTask *)jarg1;
28781   {
28782     try {
28783       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28784     } catch (std::out_of_range& e) {
28785       {
28786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28787       };
28788     } catch (std::exception& e) {
28789       {
28790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28791       };
28792     } catch (Dali::DaliException e) {
28793       {
28794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28795       };
28796     } catch (...) {
28797       {
28798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28799       };
28800     }
28801   }
28802
28803   jresult = (void *)result;
28804   return jresult;
28805 }
28806
28807
28808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28809   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28810   Dali::Actor arg2 ;
28811   Dali::Actor *argp2 ;
28812
28813   arg1 = (Dali::RenderTask *)jarg1;
28814   argp2 = (Dali::Actor *)jarg2;
28815   if (!argp2) {
28816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28817     return ;
28818   }
28819   arg2 = *argp2;
28820   {
28821     try {
28822       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28823     } catch (std::out_of_range& e) {
28824       {
28825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28826       };
28827     } catch (std::exception& e) {
28828       {
28829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28830       };
28831     } catch (Dali::DaliException e) {
28832       {
28833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28834       };
28835     } catch (...) {
28836       {
28837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28838       };
28839     }
28840   }
28841
28842 }
28843
28844
28845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28846   void * jresult ;
28847   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28848   Dali::Actor result;
28849
28850   arg1 = (Dali::RenderTask *)jarg1;
28851   {
28852     try {
28853       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28854     } catch (std::out_of_range& e) {
28855       {
28856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28857       };
28858     } catch (std::exception& e) {
28859       {
28860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28861       };
28862     } catch (Dali::DaliException e) {
28863       {
28864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28865       };
28866     } catch (...) {
28867       {
28868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28869       };
28870     }
28871   }
28872
28873   jresult = new Dali::Actor((const Dali::Actor &)result);
28874   return jresult;
28875 }
28876
28877
28878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28879   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28880   Dali::Vector2 arg2 ;
28881   Dali::Vector2 *argp2 ;
28882
28883   arg1 = (Dali::RenderTask *)jarg1;
28884   argp2 = (Dali::Vector2 *)jarg2;
28885   if (!argp2) {
28886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28887     return ;
28888   }
28889   arg2 = *argp2;
28890   {
28891     try {
28892       (arg1)->SetViewportPosition(arg2);
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28900       };
28901     } catch (Dali::DaliException e) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28904       };
28905     } catch (...) {
28906       {
28907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28908       };
28909     }
28910   }
28911
28912 }
28913
28914
28915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28916   void * jresult ;
28917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28918   Dali::Vector2 result;
28919
28920   arg1 = (Dali::RenderTask *)jarg1;
28921   {
28922     try {
28923       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28924     } catch (std::out_of_range& e) {
28925       {
28926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28927       };
28928     } catch (std::exception& e) {
28929       {
28930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28931       };
28932     } catch (Dali::DaliException e) {
28933       {
28934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28935       };
28936     } catch (...) {
28937       {
28938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28939       };
28940     }
28941   }
28942
28943   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28944   return jresult;
28945 }
28946
28947
28948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28950   Dali::Vector2 arg2 ;
28951   Dali::Vector2 *argp2 ;
28952
28953   arg1 = (Dali::RenderTask *)jarg1;
28954   argp2 = (Dali::Vector2 *)jarg2;
28955   if (!argp2) {
28956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28957     return ;
28958   }
28959   arg2 = *argp2;
28960   {
28961     try {
28962       (arg1)->SetViewportSize(arg2);
28963     } catch (std::out_of_range& e) {
28964       {
28965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (std::exception& e) {
28968       {
28969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28970       };
28971     } catch (Dali::DaliException e) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28974       };
28975     } catch (...) {
28976       {
28977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28978       };
28979     }
28980   }
28981
28982 }
28983
28984
28985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28986   void * jresult ;
28987   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28988   Dali::Vector2 result;
28989
28990   arg1 = (Dali::RenderTask *)jarg1;
28991   {
28992     try {
28993       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28994     } catch (std::out_of_range& e) {
28995       {
28996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28997       };
28998     } catch (std::exception& e) {
28999       {
29000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29001       };
29002     } catch (Dali::DaliException e) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29005       };
29006     } catch (...) {
29007       {
29008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29009       };
29010     }
29011   }
29012
29013   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29014   return jresult;
29015 }
29016
29017
29018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29019   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29020   Dali::Viewport arg2 ;
29021   Dali::Viewport *argp2 ;
29022
29023   arg1 = (Dali::RenderTask *)jarg1;
29024   argp2 = (Dali::Viewport *)jarg2;
29025   if (!argp2) {
29026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29027     return ;
29028   }
29029   arg2 = *argp2;
29030   {
29031     try {
29032       (arg1)->SetViewport(arg2);
29033     } catch (std::out_of_range& e) {
29034       {
29035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29036       };
29037     } catch (std::exception& e) {
29038       {
29039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29040       };
29041     } catch (Dali::DaliException e) {
29042       {
29043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29044       };
29045     } catch (...) {
29046       {
29047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29048       };
29049     }
29050   }
29051
29052 }
29053
29054
29055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29056   void * jresult ;
29057   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29058   Dali::Viewport result;
29059
29060   arg1 = (Dali::RenderTask *)jarg1;
29061   {
29062     try {
29063       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29064     } catch (std::out_of_range& e) {
29065       {
29066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29067       };
29068     } catch (std::exception& e) {
29069       {
29070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29071       };
29072     } catch (Dali::DaliException e) {
29073       {
29074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29075       };
29076     } catch (...) {
29077       {
29078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29079       };
29080     }
29081   }
29082
29083   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29084   return jresult;
29085 }
29086
29087
29088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29089   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29090   Dali::Vector4 *arg2 = 0 ;
29091
29092   arg1 = (Dali::RenderTask *)jarg1;
29093   arg2 = (Dali::Vector4 *)jarg2;
29094   if (!arg2) {
29095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29096     return ;
29097   }
29098   {
29099     try {
29100       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29101     } catch (std::out_of_range& e) {
29102       {
29103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29104       };
29105     } catch (std::exception& e) {
29106       {
29107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29108       };
29109     } catch (Dali::DaliException e) {
29110       {
29111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29112       };
29113     } catch (...) {
29114       {
29115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29116       };
29117     }
29118   }
29119
29120 }
29121
29122
29123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29124   void * jresult ;
29125   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29126   Dali::Vector4 result;
29127
29128   arg1 = (Dali::RenderTask *)jarg1;
29129   {
29130     try {
29131       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29132     } catch (std::out_of_range& e) {
29133       {
29134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29135       };
29136     } catch (std::exception& e) {
29137       {
29138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29139       };
29140     } catch (Dali::DaliException e) {
29141       {
29142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29143       };
29144     } catch (...) {
29145       {
29146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29147       };
29148     }
29149   }
29150
29151   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29152   return jresult;
29153 }
29154
29155
29156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29157   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29158   bool arg2 ;
29159
29160   arg1 = (Dali::RenderTask *)jarg1;
29161   arg2 = jarg2 ? true : false;
29162   {
29163     try {
29164       (arg1)->SetClearEnabled(arg2);
29165     } catch (std::out_of_range& e) {
29166       {
29167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29168       };
29169     } catch (std::exception& e) {
29170       {
29171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29172       };
29173     } catch (Dali::DaliException e) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29176       };
29177     } catch (...) {
29178       {
29179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29180       };
29181     }
29182   }
29183
29184 }
29185
29186
29187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29188   unsigned int jresult ;
29189   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29190   bool result;
29191
29192   arg1 = (Dali::RenderTask *)jarg1;
29193   {
29194     try {
29195       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29196     } catch (std::out_of_range& e) {
29197       {
29198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29199       };
29200     } catch (std::exception& e) {
29201       {
29202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29203       };
29204     } catch (Dali::DaliException e) {
29205       {
29206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29207       };
29208     } catch (...) {
29209       {
29210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29211       };
29212     }
29213   }
29214
29215   jresult = result;
29216   return jresult;
29217 }
29218
29219
29220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29222   bool arg2 ;
29223
29224   arg1 = (Dali::RenderTask *)jarg1;
29225   arg2 = jarg2 ? true : false;
29226   {
29227     try {
29228       (arg1)->SetCullMode(arg2);
29229     } catch (std::out_of_range& e) {
29230       {
29231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29232       };
29233     } catch (std::exception& e) {
29234       {
29235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29236       };
29237     } catch (Dali::DaliException e) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29240       };
29241     } catch (...) {
29242       {
29243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29244       };
29245     }
29246   }
29247
29248 }
29249
29250
29251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29252   unsigned int jresult ;
29253   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29254   bool result;
29255
29256   arg1 = (Dali::RenderTask *)jarg1;
29257   {
29258     try {
29259       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29260     } catch (std::out_of_range& e) {
29261       {
29262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (std::exception& e) {
29265       {
29266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29267       };
29268     } catch (Dali::DaliException e) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29271       };
29272     } catch (...) {
29273       {
29274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29275       };
29276     }
29277   }
29278
29279   jresult = result;
29280   return jresult;
29281 }
29282
29283
29284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29285   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29286   unsigned int arg2 ;
29287
29288   arg1 = (Dali::RenderTask *)jarg1;
29289   arg2 = (unsigned int)jarg2;
29290   {
29291     try {
29292       (arg1)->SetRefreshRate(arg2);
29293     } catch (std::out_of_range& e) {
29294       {
29295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (std::exception& e) {
29298       {
29299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29300       };
29301     } catch (Dali::DaliException e) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29304       };
29305     } catch (...) {
29306       {
29307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29308       };
29309     }
29310   }
29311
29312 }
29313
29314
29315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29316   unsigned int jresult ;
29317   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29318   unsigned int result;
29319
29320   arg1 = (Dali::RenderTask *)jarg1;
29321   {
29322     try {
29323       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29324     } catch (std::out_of_range& e) {
29325       {
29326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (std::exception& e) {
29329       {
29330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29331       };
29332     } catch (Dali::DaliException e) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29335       };
29336     } catch (...) {
29337       {
29338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29339       };
29340     }
29341   }
29342
29343   jresult = result;
29344   return jresult;
29345 }
29346
29347
29348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29349   unsigned int jresult ;
29350   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29351   Dali::Vector3 *arg2 = 0 ;
29352   float *arg3 = 0 ;
29353   float *arg4 = 0 ;
29354   bool result;
29355
29356   arg1 = (Dali::RenderTask *)jarg1;
29357   arg2 = (Dali::Vector3 *)jarg2;
29358   if (!arg2) {
29359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29360     return 0;
29361   }
29362   arg3 = (float *)jarg3;
29363   arg4 = (float *)jarg4;
29364   {
29365     try {
29366       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29367     } catch (std::out_of_range& e) {
29368       {
29369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29370       };
29371     } catch (std::exception& e) {
29372       {
29373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29374       };
29375     } catch (Dali::DaliException e) {
29376       {
29377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29378       };
29379     } catch (...) {
29380       {
29381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29382       };
29383     }
29384   }
29385
29386   jresult = result;
29387   return jresult;
29388 }
29389
29390
29391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29392   unsigned int jresult ;
29393   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29394   Dali::Actor arg2 ;
29395   float arg3 ;
29396   float arg4 ;
29397   float *arg5 = 0 ;
29398   float *arg6 = 0 ;
29399   Dali::Actor *argp2 ;
29400   bool result;
29401
29402   arg1 = (Dali::RenderTask *)jarg1;
29403   argp2 = (Dali::Actor *)jarg2;
29404   if (!argp2) {
29405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29406     return 0;
29407   }
29408   arg2 = *argp2;
29409   arg3 = (float)jarg3;
29410   arg4 = (float)jarg4;
29411   arg5 = (float *)jarg5;
29412   arg6 = (float *)jarg6;
29413   {
29414     try {
29415       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29416     } catch (std::out_of_range& e) {
29417       {
29418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29419       };
29420     } catch (std::exception& e) {
29421       {
29422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29423       };
29424     } catch (Dali::DaliException e) {
29425       {
29426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29427       };
29428     } catch (...) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29431       };
29432     }
29433   }
29434
29435   jresult = result;
29436   return jresult;
29437 }
29438
29439
29440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29441   void * jresult ;
29442   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29443   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29444
29445   arg1 = (Dali::RenderTask *)jarg1;
29446   {
29447     try {
29448       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29449     } catch (std::out_of_range& e) {
29450       {
29451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29452       };
29453     } catch (std::exception& e) {
29454       {
29455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29456       };
29457     } catch (Dali::DaliException e) {
29458       {
29459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29460       };
29461     } catch (...) {
29462       {
29463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29464       };
29465     }
29466   }
29467
29468   jresult = (void *)result;
29469   return jresult;
29470 }
29471
29472
29473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29474   void * jresult ;
29475   int arg1 ;
29476   Dali::TouchPoint::State arg2 ;
29477   float arg3 ;
29478   float arg4 ;
29479   Dali::TouchPoint *result = 0 ;
29480
29481   arg1 = (int)jarg1;
29482   arg2 = (Dali::TouchPoint::State)jarg2;
29483   arg3 = (float)jarg3;
29484   arg4 = (float)jarg4;
29485   {
29486     try {
29487       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29488     } catch (std::out_of_range& e) {
29489       {
29490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29491       };
29492     } catch (std::exception& e) {
29493       {
29494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29495       };
29496     } catch (Dali::DaliException e) {
29497       {
29498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29499       };
29500     } catch (...) {
29501       {
29502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29503       };
29504     }
29505   }
29506
29507   jresult = (void *)result;
29508   return jresult;
29509 }
29510
29511
29512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29513   void * jresult ;
29514   int arg1 ;
29515   Dali::TouchPoint::State arg2 ;
29516   float arg3 ;
29517   float arg4 ;
29518   float arg5 ;
29519   float arg6 ;
29520   Dali::TouchPoint *result = 0 ;
29521
29522   arg1 = (int)jarg1;
29523   arg2 = (Dali::TouchPoint::State)jarg2;
29524   arg3 = (float)jarg3;
29525   arg4 = (float)jarg4;
29526   arg5 = (float)jarg5;
29527   arg6 = (float)jarg6;
29528   {
29529     try {
29530       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29531     } catch (std::out_of_range& e) {
29532       {
29533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29534       };
29535     } catch (std::exception& e) {
29536       {
29537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (Dali::DaliException e) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29542       };
29543     } catch (...) {
29544       {
29545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29546       };
29547     }
29548   }
29549
29550   jresult = (void *)result;
29551   return jresult;
29552 }
29553
29554
29555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29556   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29557
29558   arg1 = (Dali::TouchPoint *)jarg1;
29559   {
29560     try {
29561       delete arg1;
29562     } catch (std::out_of_range& e) {
29563       {
29564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29565       };
29566     } catch (std::exception& e) {
29567       {
29568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29569       };
29570     } catch (Dali::DaliException e) {
29571       {
29572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29573       };
29574     } catch (...) {
29575       {
29576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29577       };
29578     }
29579   }
29580
29581 }
29582
29583
29584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29585   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29586   int arg2 ;
29587
29588   arg1 = (Dali::TouchPoint *)jarg1;
29589   arg2 = (int)jarg2;
29590   if (arg1) (arg1)->deviceId = arg2;
29591 }
29592
29593
29594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29595   int jresult ;
29596   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29597   int result;
29598
29599   arg1 = (Dali::TouchPoint *)jarg1;
29600   result = (int) ((arg1)->deviceId);
29601   jresult = result;
29602   return jresult;
29603 }
29604
29605
29606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29607   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29608   Dali::TouchPoint::State arg2 ;
29609
29610   arg1 = (Dali::TouchPoint *)jarg1;
29611   arg2 = (Dali::TouchPoint::State)jarg2;
29612   if (arg1) (arg1)->state = arg2;
29613 }
29614
29615
29616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29617   int jresult ;
29618   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29619   Dali::TouchPoint::State result;
29620
29621   arg1 = (Dali::TouchPoint *)jarg1;
29622   result = (Dali::TouchPoint::State) ((arg1)->state);
29623   jresult = (int)result;
29624   return jresult;
29625 }
29626
29627
29628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29629   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29630   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29631
29632   arg1 = (Dali::TouchPoint *)jarg1;
29633   arg2 = (Dali::Actor *)jarg2;
29634   if (arg1) (arg1)->hitActor = *arg2;
29635 }
29636
29637
29638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29639   void * jresult ;
29640   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29641   Dali::Actor *result = 0 ;
29642
29643   arg1 = (Dali::TouchPoint *)jarg1;
29644   result = (Dali::Actor *)& ((arg1)->hitActor);
29645   jresult = (void *)result;
29646   return jresult;
29647 }
29648
29649
29650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29651   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29652   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29653
29654   arg1 = (Dali::TouchPoint *)jarg1;
29655   arg2 = (Dali::Vector2 *)jarg2;
29656   if (arg1) (arg1)->local = *arg2;
29657 }
29658
29659
29660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29661   void * jresult ;
29662   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29663   Dali::Vector2 *result = 0 ;
29664
29665   arg1 = (Dali::TouchPoint *)jarg1;
29666   result = (Dali::Vector2 *)& ((arg1)->local);
29667   jresult = (void *)result;
29668   return jresult;
29669 }
29670
29671
29672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29673   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29674   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29675
29676   arg1 = (Dali::TouchPoint *)jarg1;
29677   arg2 = (Dali::Vector2 *)jarg2;
29678   if (arg1) (arg1)->screen = *arg2;
29679 }
29680
29681
29682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29683   void * jresult ;
29684   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29685   Dali::Vector2 *result = 0 ;
29686
29687   arg1 = (Dali::TouchPoint *)jarg1;
29688   result = (Dali::Vector2 *)& ((arg1)->screen);
29689   jresult = (void *)result;
29690   return jresult;
29691 }
29692
29693
29694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29695   void * jresult ;
29696   Dali::TouchData *result = 0 ;
29697
29698   {
29699     try {
29700       result = (Dali::TouchData *)new Dali::TouchData();
29701     } catch (std::out_of_range& e) {
29702       {
29703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29704       };
29705     } catch (std::exception& e) {
29706       {
29707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (Dali::DaliException e) {
29710       {
29711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29712       };
29713     } catch (...) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29716       };
29717     }
29718   }
29719
29720   jresult = (void *)result;
29721   return jresult;
29722 }
29723
29724
29725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29726   void * jresult ;
29727   Dali::TouchData *arg1 = 0 ;
29728   Dali::TouchData *result = 0 ;
29729
29730   arg1 = (Dali::TouchData *)jarg1;
29731   if (!arg1) {
29732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29733     return 0;
29734   }
29735   {
29736     try {
29737       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29738     } catch (std::out_of_range& e) {
29739       {
29740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (std::exception& e) {
29743       {
29744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (Dali::DaliException e) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29749       };
29750     } catch (...) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29753       };
29754     }
29755   }
29756
29757   jresult = (void *)result;
29758   return jresult;
29759 }
29760
29761
29762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29763   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29764
29765   arg1 = (Dali::TouchData *)jarg1;
29766   {
29767     try {
29768       delete arg1;
29769     } catch (std::out_of_range& e) {
29770       {
29771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29772       };
29773     } catch (std::exception& e) {
29774       {
29775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29776       };
29777     } catch (Dali::DaliException e) {
29778       {
29779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29780       };
29781     } catch (...) {
29782       {
29783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29784       };
29785     }
29786   }
29787
29788 }
29789
29790
29791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29792   void * jresult ;
29793   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29794   Dali::TouchData *arg2 = 0 ;
29795   Dali::TouchData *result = 0 ;
29796
29797   arg1 = (Dali::TouchData *)jarg1;
29798   arg2 = (Dali::TouchData *)jarg2;
29799   if (!arg2) {
29800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29801     return 0;
29802   }
29803   {
29804     try {
29805       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29806     } catch (std::out_of_range& e) {
29807       {
29808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29809       };
29810     } catch (std::exception& e) {
29811       {
29812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29813       };
29814     } catch (Dali::DaliException e) {
29815       {
29816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29817       };
29818     } catch (...) {
29819       {
29820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29821       };
29822     }
29823   }
29824
29825   jresult = (void *)result;
29826   return jresult;
29827 }
29828
29829
29830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29831   unsigned long jresult ;
29832   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29833   unsigned long result;
29834
29835   arg1 = (Dali::TouchData *)jarg1;
29836   {
29837     try {
29838       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29839     } catch (std::out_of_range& e) {
29840       {
29841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29842       };
29843     } catch (std::exception& e) {
29844       {
29845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29846       };
29847     } catch (Dali::DaliException e) {
29848       {
29849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29850       };
29851     } catch (...) {
29852       {
29853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29854       };
29855     }
29856   }
29857
29858   jresult = (unsigned long)result;
29859   return jresult;
29860 }
29861
29862
29863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29864   unsigned long jresult ;
29865   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29866   std::size_t result;
29867
29868   arg1 = (Dali::TouchData *)jarg1;
29869   {
29870     try {
29871       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29872     } catch (std::out_of_range& e) {
29873       {
29874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29875       };
29876     } catch (std::exception& e) {
29877       {
29878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29879       };
29880     } catch (Dali::DaliException e) {
29881       {
29882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29883       };
29884     } catch (...) {
29885       {
29886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29887       };
29888     }
29889   }
29890
29891   jresult = (unsigned long)result;
29892   return jresult;
29893 }
29894
29895
29896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29897   int jresult ;
29898   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29899   std::size_t arg2 ;
29900   int32_t result;
29901
29902   arg1 = (Dali::TouchData *)jarg1;
29903   arg2 = (std::size_t)jarg2;
29904   {
29905     try {
29906       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29907     } catch (std::out_of_range& e) {
29908       {
29909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29910       };
29911     } catch (std::exception& e) {
29912       {
29913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29914       };
29915     } catch (Dali::DaliException e) {
29916       {
29917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29918       };
29919     } catch (...) {
29920       {
29921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29922       };
29923     }
29924   }
29925
29926   jresult = result;
29927   return jresult;
29928 }
29929
29930
29931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29932   int jresult ;
29933   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29934   std::size_t arg2 ;
29935   Dali::PointState::Type result;
29936
29937   arg1 = (Dali::TouchData *)jarg1;
29938   arg2 = (std::size_t)jarg2;
29939   {
29940     try {
29941       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29942     } catch (std::out_of_range& e) {
29943       {
29944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29945       };
29946     } catch (std::exception& e) {
29947       {
29948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29949       };
29950     } catch (Dali::DaliException e) {
29951       {
29952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29953       };
29954     } catch (...) {
29955       {
29956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29957       };
29958     }
29959   }
29960
29961   jresult = (int)result;
29962   return jresult;
29963 }
29964
29965
29966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29967   void * jresult ;
29968   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29969   std::size_t arg2 ;
29970   Dali::Actor result;
29971
29972   arg1 = (Dali::TouchData *)jarg1;
29973   arg2 = (std::size_t)jarg2;
29974   {
29975     try {
29976       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29977     } catch (std::out_of_range& e) {
29978       {
29979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29980       };
29981     } catch (std::exception& e) {
29982       {
29983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29984       };
29985     } catch (Dali::DaliException e) {
29986       {
29987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29988       };
29989     } catch (...) {
29990       {
29991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29992       };
29993     }
29994   }
29995
29996   jresult = new Dali::Actor((const Dali::Actor &)result);
29997   return jresult;
29998 }
29999
30000
30001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30002   void * jresult ;
30003   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30004   std::size_t arg2 ;
30005   Dali::Vector2 *result = 0 ;
30006
30007   arg1 = (Dali::TouchData *)jarg1;
30008   arg2 = (std::size_t)jarg2;
30009   {
30010     try {
30011       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30012     } catch (std::out_of_range& e) {
30013       {
30014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (std::exception& e) {
30017       {
30018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30019       };
30020     } catch (Dali::DaliException e) {
30021       {
30022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30023       };
30024     } catch (...) {
30025       {
30026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30027       };
30028     }
30029   }
30030
30031   jresult = (void *)result;
30032   return jresult;
30033 }
30034
30035
30036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30037   void * jresult ;
30038   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30039   std::size_t arg2 ;
30040   Dali::Vector2 *result = 0 ;
30041
30042   arg1 = (Dali::TouchData *)jarg1;
30043   arg2 = (std::size_t)jarg2;
30044   {
30045     try {
30046       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30047     } catch (std::out_of_range& e) {
30048       {
30049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30050       };
30051     } catch (std::exception& e) {
30052       {
30053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30054       };
30055     } catch (Dali::DaliException e) {
30056       {
30057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30058       };
30059     } catch (...) {
30060       {
30061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30062       };
30063     }
30064   }
30065
30066   jresult = (void *)result;
30067   return jresult;
30068 }
30069
30070
30071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30072   float jresult ;
30073   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30074   std::size_t arg2 ;
30075   float result;
30076
30077   arg1 = (Dali::TouchData *)jarg1;
30078   arg2 = (std::size_t)jarg2;
30079   {
30080     try {
30081       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30082     } catch (std::out_of_range& e) {
30083       {
30084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30085       };
30086     } catch (std::exception& e) {
30087       {
30088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30089       };
30090     } catch (Dali::DaliException e) {
30091       {
30092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30093       };
30094     } catch (...) {
30095       {
30096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30097       };
30098     }
30099   }
30100
30101   jresult = result;
30102   return jresult;
30103 }
30104
30105
30106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30107   void * jresult ;
30108   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30109   std::size_t arg2 ;
30110   Dali::Vector2 *result = 0 ;
30111
30112   arg1 = (Dali::TouchData *)jarg1;
30113   arg2 = (std::size_t)jarg2;
30114   {
30115     try {
30116       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30117     } catch (std::out_of_range& e) {
30118       {
30119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30120       };
30121     } catch (std::exception& e) {
30122       {
30123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30124       };
30125     } catch (Dali::DaliException e) {
30126       {
30127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30128       };
30129     } catch (...) {
30130       {
30131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30132       };
30133     }
30134   }
30135
30136   jresult = (void *)result;
30137   return jresult;
30138 }
30139
30140
30141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30142   float jresult ;
30143   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30144   std::size_t arg2 ;
30145   float result;
30146
30147   arg1 = (Dali::TouchData *)jarg1;
30148   arg2 = (std::size_t)jarg2;
30149   {
30150     try {
30151       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30152     } catch (std::out_of_range& e) {
30153       {
30154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30155       };
30156     } catch (std::exception& e) {
30157       {
30158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30159       };
30160     } catch (Dali::DaliException e) {
30161       {
30162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30163       };
30164     } catch (...) {
30165       {
30166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30167       };
30168     }
30169   }
30170
30171   jresult = result;
30172   return jresult;
30173 }
30174
30175
30176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30177   void * jresult ;
30178   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30179   std::size_t arg2 ;
30180   Dali::Degree result;
30181
30182   arg1 = (Dali::TouchData *)jarg1;
30183   arg2 = (std::size_t)jarg2;
30184   {
30185     try {
30186       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30187     } catch (std::out_of_range& e) {
30188       {
30189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30190       };
30191     } catch (std::exception& e) {
30192       {
30193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30194       };
30195     } catch (Dali::DaliException e) {
30196       {
30197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30198       };
30199     } catch (...) {
30200       {
30201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30202       };
30203     }
30204   }
30205
30206   jresult = new Dali::Degree((const Dali::Degree &)result);
30207   return jresult;
30208 }
30209
30210
30211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30212   int jresult ;
30213   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30214   std::size_t arg2 ;
30215   Dali::MouseButton::Type result;
30216
30217   arg1 = (Dali::TouchData *)jarg1;
30218   arg2 = (std::size_t)jarg2;
30219   {
30220     try {
30221       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30222     } catch (std::out_of_range& e) {
30223       {
30224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30225       };
30226     } catch (std::exception& e) {
30227       {
30228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30229       };
30230     } catch (Dali::DaliException e) {
30231       {
30232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30233       };
30234     } catch (...) {
30235       {
30236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30237       };
30238     }
30239   }
30240
30241   jresult = static_cast< int >(result);
30242   return jresult;
30243 }
30244
30245
30246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30247   void * jresult ;
30248   Dali::GestureDetector *result = 0 ;
30249
30250   {
30251     try {
30252       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30253     } catch (std::out_of_range& e) {
30254       {
30255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30256       };
30257     } catch (std::exception& e) {
30258       {
30259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30260       };
30261     } catch (Dali::DaliException e) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30264       };
30265     } catch (...) {
30266       {
30267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30268       };
30269     }
30270   }
30271
30272   jresult = (void *)result;
30273   return jresult;
30274 }
30275
30276
30277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30278   void * jresult ;
30279   Dali::BaseHandle arg1 ;
30280   Dali::BaseHandle *argp1 ;
30281   Dali::GestureDetector result;
30282
30283   argp1 = (Dali::BaseHandle *)jarg1;
30284   if (!argp1) {
30285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30286     return 0;
30287   }
30288   arg1 = *argp1;
30289   {
30290     try {
30291       result = Dali::GestureDetector::DownCast(arg1);
30292     } catch (std::out_of_range& e) {
30293       {
30294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (std::exception& e) {
30297       {
30298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (Dali::DaliException e) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30303       };
30304     } catch (...) {
30305       {
30306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30307       };
30308     }
30309   }
30310
30311   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30312   return jresult;
30313 }
30314
30315
30316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30317   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30318
30319   arg1 = (Dali::GestureDetector *)jarg1;
30320   {
30321     try {
30322       delete arg1;
30323     } catch (std::out_of_range& e) {
30324       {
30325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (std::exception& e) {
30328       {
30329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (Dali::DaliException e) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30334       };
30335     } catch (...) {
30336       {
30337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30338       };
30339     }
30340   }
30341
30342 }
30343
30344
30345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30346   void * jresult ;
30347   Dali::GestureDetector *arg1 = 0 ;
30348   Dali::GestureDetector *result = 0 ;
30349
30350   arg1 = (Dali::GestureDetector *)jarg1;
30351   if (!arg1) {
30352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30353     return 0;
30354   }
30355   {
30356     try {
30357       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30358     } catch (std::out_of_range& e) {
30359       {
30360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30361       };
30362     } catch (std::exception& e) {
30363       {
30364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30365       };
30366     } catch (Dali::DaliException e) {
30367       {
30368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30369       };
30370     } catch (...) {
30371       {
30372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30373       };
30374     }
30375   }
30376
30377   jresult = (void *)result;
30378   return jresult;
30379 }
30380
30381
30382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30383   void * jresult ;
30384   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30385   Dali::GestureDetector *arg2 = 0 ;
30386   Dali::GestureDetector *result = 0 ;
30387
30388   arg1 = (Dali::GestureDetector *)jarg1;
30389   arg2 = (Dali::GestureDetector *)jarg2;
30390   if (!arg2) {
30391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30392     return 0;
30393   }
30394   {
30395     try {
30396       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30397     } catch (std::out_of_range& e) {
30398       {
30399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30400       };
30401     } catch (std::exception& e) {
30402       {
30403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30404       };
30405     } catch (Dali::DaliException e) {
30406       {
30407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30408       };
30409     } catch (...) {
30410       {
30411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30412       };
30413     }
30414   }
30415
30416   jresult = (void *)result;
30417   return jresult;
30418 }
30419
30420
30421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30422   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30423   Dali::Actor arg2 ;
30424   Dali::Actor *argp2 ;
30425
30426   arg1 = (Dali::GestureDetector *)jarg1;
30427   argp2 = (Dali::Actor *)jarg2;
30428   if (!argp2) {
30429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30430     return ;
30431   }
30432   arg2 = *argp2;
30433   {
30434     try {
30435       (arg1)->Attach(arg2);
30436     } catch (std::out_of_range& e) {
30437       {
30438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (std::exception& e) {
30441       {
30442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30443       };
30444     } catch (Dali::DaliException e) {
30445       {
30446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30447       };
30448     } catch (...) {
30449       {
30450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30451       };
30452     }
30453   }
30454
30455 }
30456
30457
30458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30459   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30460   Dali::Actor arg2 ;
30461   Dali::Actor *argp2 ;
30462
30463   arg1 = (Dali::GestureDetector *)jarg1;
30464   argp2 = (Dali::Actor *)jarg2;
30465   if (!argp2) {
30466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30467     return ;
30468   }
30469   arg2 = *argp2;
30470   {
30471     try {
30472       (arg1)->Detach(arg2);
30473     } catch (std::out_of_range& e) {
30474       {
30475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30476       };
30477     } catch (std::exception& e) {
30478       {
30479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30480       };
30481     } catch (Dali::DaliException e) {
30482       {
30483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30484       };
30485     } catch (...) {
30486       {
30487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30488       };
30489     }
30490   }
30491
30492 }
30493
30494
30495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30496   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30497
30498   arg1 = (Dali::GestureDetector *)jarg1;
30499   {
30500     try {
30501       (arg1)->DetachAll();
30502     } catch (std::out_of_range& e) {
30503       {
30504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30505       };
30506     } catch (std::exception& e) {
30507       {
30508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30509       };
30510     } catch (Dali::DaliException e) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30513       };
30514     } catch (...) {
30515       {
30516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30517       };
30518     }
30519   }
30520
30521 }
30522
30523
30524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30525   unsigned long jresult ;
30526   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30527   size_t result;
30528
30529   arg1 = (Dali::GestureDetector *)jarg1;
30530   {
30531     try {
30532       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30533     } catch (std::out_of_range& e) {
30534       {
30535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30536       };
30537     } catch (std::exception& e) {
30538       {
30539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30540       };
30541     } catch (Dali::DaliException e) {
30542       {
30543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30544       };
30545     } catch (...) {
30546       {
30547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30548       };
30549     }
30550   }
30551
30552   jresult = (unsigned long)result;
30553   return jresult;
30554 }
30555
30556
30557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30558   void * jresult ;
30559   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30560   size_t arg2 ;
30561   Dali::Actor result;
30562
30563   arg1 = (Dali::GestureDetector *)jarg1;
30564   arg2 = (size_t)jarg2;
30565   {
30566     try {
30567       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30568     } catch (std::out_of_range& e) {
30569       {
30570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30571       };
30572     } catch (std::exception& e) {
30573       {
30574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30575       };
30576     } catch (Dali::DaliException e) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30579       };
30580     } catch (...) {
30581       {
30582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30583       };
30584     }
30585   }
30586
30587   jresult = new Dali::Actor((const Dali::Actor &)result);
30588   return jresult;
30589 }
30590
30591
30592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30593   void * jresult ;
30594   Dali::Gesture *arg1 = 0 ;
30595   Dali::Gesture *result = 0 ;
30596
30597   arg1 = (Dali::Gesture *)jarg1;
30598   if (!arg1) {
30599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30600     return 0;
30601   }
30602   {
30603     try {
30604       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30605     } catch (std::out_of_range& e) {
30606       {
30607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30608       };
30609     } catch (std::exception& e) {
30610       {
30611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30612       };
30613     } catch (Dali::DaliException e) {
30614       {
30615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30616       };
30617     } catch (...) {
30618       {
30619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30620       };
30621     }
30622   }
30623
30624   jresult = (void *)result;
30625   return jresult;
30626 }
30627
30628
30629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30630   void * jresult ;
30631   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30632   Dali::Gesture *arg2 = 0 ;
30633   Dali::Gesture *result = 0 ;
30634
30635   arg1 = (Dali::Gesture *)jarg1;
30636   arg2 = (Dali::Gesture *)jarg2;
30637   if (!arg2) {
30638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30639     return 0;
30640   }
30641   {
30642     try {
30643       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30644     } catch (std::out_of_range& e) {
30645       {
30646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30647       };
30648     } catch (std::exception& e) {
30649       {
30650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30651       };
30652     } catch (Dali::DaliException e) {
30653       {
30654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30655       };
30656     } catch (...) {
30657       {
30658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30659       };
30660     }
30661   }
30662
30663   jresult = (void *)result;
30664   return jresult;
30665 }
30666
30667
30668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30669   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30670
30671   arg1 = (Dali::Gesture *)jarg1;
30672   {
30673     try {
30674       delete arg1;
30675     } catch (std::out_of_range& e) {
30676       {
30677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30678       };
30679     } catch (std::exception& e) {
30680       {
30681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30682       };
30683     } catch (Dali::DaliException e) {
30684       {
30685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30686       };
30687     } catch (...) {
30688       {
30689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30690       };
30691     }
30692   }
30693
30694 }
30695
30696
30697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30698   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30699   Dali::Gesture::Type arg2 ;
30700
30701   arg1 = (Dali::Gesture *)jarg1;
30702   arg2 = (Dali::Gesture::Type)jarg2;
30703   if (arg1) (arg1)->type = arg2;
30704 }
30705
30706
30707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30708   int jresult ;
30709   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30710   Dali::Gesture::Type result;
30711
30712   arg1 = (Dali::Gesture *)jarg1;
30713   result = (Dali::Gesture::Type) ((arg1)->type);
30714   jresult = (int)result;
30715   return jresult;
30716 }
30717
30718
30719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30720   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30721   Dali::Gesture::State arg2 ;
30722
30723   arg1 = (Dali::Gesture *)jarg1;
30724   arg2 = (Dali::Gesture::State)jarg2;
30725   if (arg1) (arg1)->state = arg2;
30726 }
30727
30728
30729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30730   int jresult ;
30731   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30732   Dali::Gesture::State result;
30733
30734   arg1 = (Dali::Gesture *)jarg1;
30735   result = (Dali::Gesture::State) ((arg1)->state);
30736   jresult = (int)result;
30737   return jresult;
30738 }
30739
30740
30741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30742   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30743   unsigned int arg2 ;
30744
30745   arg1 = (Dali::Gesture *)jarg1;
30746   arg2 = (unsigned int)jarg2;
30747   if (arg1) (arg1)->time = arg2;
30748 }
30749
30750
30751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30752   unsigned int jresult ;
30753   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30754   unsigned int result;
30755
30756   arg1 = (Dali::Gesture *)jarg1;
30757   result = (unsigned int) ((arg1)->time);
30758   jresult = result;
30759   return jresult;
30760 }
30761
30762
30763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30764   void * jresult ;
30765   Dali::HoverEvent *result = 0 ;
30766
30767   {
30768     try {
30769       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30770     } catch (std::out_of_range& e) {
30771       {
30772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30773       };
30774     } catch (std::exception& e) {
30775       {
30776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30777       };
30778     } catch (Dali::DaliException e) {
30779       {
30780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30781       };
30782     } catch (...) {
30783       {
30784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30785       };
30786     }
30787   }
30788
30789   jresult = (void *)result;
30790   return jresult;
30791 }
30792
30793
30794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30795   void * jresult ;
30796   unsigned long arg1 ;
30797   Dali::HoverEvent *result = 0 ;
30798
30799   arg1 = (unsigned long)jarg1;
30800   {
30801     try {
30802       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30803     } catch (std::out_of_range& e) {
30804       {
30805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30806       };
30807     } catch (std::exception& e) {
30808       {
30809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30810       };
30811     } catch (Dali::DaliException e) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30814       };
30815     } catch (...) {
30816       {
30817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30818       };
30819     }
30820   }
30821
30822   jresult = (void *)result;
30823   return jresult;
30824 }
30825
30826
30827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30828   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30829
30830   arg1 = (Dali::HoverEvent *)jarg1;
30831   {
30832     try {
30833       delete arg1;
30834     } catch (std::out_of_range& e) {
30835       {
30836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30837       };
30838     } catch (std::exception& e) {
30839       {
30840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30841       };
30842     } catch (Dali::DaliException e) {
30843       {
30844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30845       };
30846     } catch (...) {
30847       {
30848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30849       };
30850     }
30851   }
30852
30853 }
30854
30855
30856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30857   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30858   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30859
30860   arg1 = (Dali::HoverEvent *)jarg1;
30861   arg2 = (Dali::TouchPointContainer *)jarg2;
30862   if (arg1) (arg1)->points = *arg2;
30863 }
30864
30865
30866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30867   void * jresult ;
30868   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30869   Dali::TouchPointContainer *result = 0 ;
30870
30871   arg1 = (Dali::HoverEvent *)jarg1;
30872   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30873   jresult = (void *)result;
30874   return jresult;
30875 }
30876
30877
30878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30879   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30880   unsigned long arg2 ;
30881
30882   arg1 = (Dali::HoverEvent *)jarg1;
30883   arg2 = (unsigned long)jarg2;
30884   if (arg1) (arg1)->time = arg2;
30885 }
30886
30887
30888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30889   unsigned long jresult ;
30890   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30891   unsigned long result;
30892
30893   arg1 = (Dali::HoverEvent *)jarg1;
30894   result = (unsigned long) ((arg1)->time);
30895   jresult = (unsigned long)result;
30896   return jresult;
30897 }
30898
30899
30900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30901   unsigned int jresult ;
30902   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30903   unsigned int result;
30904
30905   arg1 = (Dali::HoverEvent *)jarg1;
30906   {
30907     try {
30908       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30909     } catch (std::out_of_range& e) {
30910       {
30911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30912       };
30913     } catch (std::exception& e) {
30914       {
30915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (Dali::DaliException e) {
30918       {
30919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30920       };
30921     } catch (...) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30924       };
30925     }
30926   }
30927
30928   jresult = result;
30929   return jresult;
30930 }
30931
30932
30933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30934   void * jresult ;
30935   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30936   unsigned int arg2 ;
30937   Dali::TouchPoint *result = 0 ;
30938
30939   arg1 = (Dali::HoverEvent *)jarg1;
30940   arg2 = (unsigned int)jarg2;
30941   {
30942     try {
30943       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30944     } catch (std::out_of_range& e) {
30945       {
30946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30947       };
30948     } catch (std::exception& e) {
30949       {
30950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30951       };
30952     } catch (Dali::DaliException e) {
30953       {
30954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30955       };
30956     } catch (...) {
30957       {
30958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30959       };
30960     }
30961   }
30962
30963   jresult = (void *)result;
30964   return jresult;
30965 }
30966
30967
30968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30969   void * jresult ;
30970   Dali::KeyEvent *result = 0 ;
30971
30972   {
30973     try {
30974       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30975     } catch (std::out_of_range& e) {
30976       {
30977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30978       };
30979     } catch (std::exception& e) {
30980       {
30981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30982       };
30983     } catch (Dali::DaliException e) {
30984       {
30985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30986       };
30987     } catch (...) {
30988       {
30989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30990       };
30991     }
30992   }
30993
30994   jresult = (void *)result;
30995   return jresult;
30996 }
30997
30998
30999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31000   void * jresult ;
31001   std::string *arg1 = 0 ;
31002   std::string *arg2 = 0 ;
31003   int arg3 ;
31004   int arg4 ;
31005   unsigned long arg5 ;
31006   Dali::KeyEvent::State *arg6 = 0 ;
31007   Dali::KeyEvent::State temp6 ;
31008   Dali::KeyEvent *result = 0 ;
31009
31010   if (!jarg1) {
31011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31012     return 0;
31013   }
31014   std::string arg1_str(jarg1);
31015   arg1 = &arg1_str;
31016   if (!jarg2) {
31017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31018     return 0;
31019   }
31020   std::string arg2_str(jarg2);
31021   arg2 = &arg2_str;
31022   arg3 = (int)jarg3;
31023   arg4 = (int)jarg4;
31024   arg5 = (unsigned long)jarg5;
31025   temp6 = (Dali::KeyEvent::State)jarg6;
31026   arg6 = &temp6;
31027   {
31028     try {
31029       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31030     } catch (std::out_of_range& e) {
31031       {
31032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31033       };
31034     } catch (std::exception& e) {
31035       {
31036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31037       };
31038     } catch (Dali::DaliException e) {
31039       {
31040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31041       };
31042     } catch (...) {
31043       {
31044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31045       };
31046     }
31047   }
31048
31049   jresult = (void *)result;
31050
31051   //argout typemap for const std::string&
31052
31053
31054   //argout typemap for const std::string&
31055
31056   return jresult;
31057 }
31058
31059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31060   void * jresult ;
31061   Dali::KeyEvent *arg1 = 0 ;
31062   Dali::KeyEvent *result = 0 ;
31063
31064   arg1 = (Dali::KeyEvent *)jarg1;
31065   if (!arg1) {
31066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31067     return 0;
31068   }
31069   {
31070     try {
31071       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31072     } catch (std::out_of_range& e) {
31073       {
31074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31075       };
31076     } catch (std::exception& e) {
31077       {
31078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31079       };
31080     } catch (Dali::DaliException e) {
31081       {
31082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31083       };
31084     } catch (...) {
31085       {
31086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31087       };
31088     }
31089   }
31090
31091   jresult = (void *)result;
31092   return jresult;
31093 }
31094
31095
31096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31097   void * jresult ;
31098   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31099   Dali::KeyEvent *arg2 = 0 ;
31100   Dali::KeyEvent *result = 0 ;
31101
31102   arg1 = (Dali::KeyEvent *)jarg1;
31103   arg2 = (Dali::KeyEvent *)jarg2;
31104   if (!arg2) {
31105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31106     return 0;
31107   }
31108   {
31109     try {
31110       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31111     } catch (std::out_of_range& e) {
31112       {
31113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (std::exception& e) {
31116       {
31117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31118       };
31119     } catch (Dali::DaliException e) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31122       };
31123     } catch (...) {
31124       {
31125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31126       };
31127     }
31128   }
31129
31130   jresult = (void *)result;
31131   return jresult;
31132 }
31133
31134
31135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31136   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31137
31138   arg1 = (Dali::KeyEvent *)jarg1;
31139   {
31140     try {
31141       delete arg1;
31142     } catch (std::out_of_range& e) {
31143       {
31144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31145       };
31146     } catch (std::exception& e) {
31147       {
31148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31149       };
31150     } catch (Dali::DaliException e) {
31151       {
31152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31153       };
31154     } catch (...) {
31155       {
31156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31157       };
31158     }
31159   }
31160
31161 }
31162
31163
31164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31165   unsigned int jresult ;
31166   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31167   bool result;
31168
31169   arg1 = (Dali::KeyEvent *)jarg1;
31170   {
31171     try {
31172       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31173     } catch (std::out_of_range& e) {
31174       {
31175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31176       };
31177     } catch (std::exception& e) {
31178       {
31179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31180       };
31181     } catch (Dali::DaliException e) {
31182       {
31183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31188       };
31189     }
31190   }
31191
31192   jresult = result;
31193   return jresult;
31194 }
31195
31196
31197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31198   unsigned int jresult ;
31199   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31200   bool result;
31201
31202   arg1 = (Dali::KeyEvent *)jarg1;
31203   {
31204     try {
31205       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31206     } catch (std::out_of_range& e) {
31207       {
31208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31209       };
31210     } catch (std::exception& e) {
31211       {
31212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31213       };
31214     } catch (Dali::DaliException e) {
31215       {
31216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31217       };
31218     } catch (...) {
31219       {
31220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31221       };
31222     }
31223   }
31224
31225   jresult = result;
31226   return jresult;
31227 }
31228
31229
31230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31231   unsigned int jresult ;
31232   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31233   bool result;
31234
31235   arg1 = (Dali::KeyEvent *)jarg1;
31236   {
31237     try {
31238       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31239     } catch (std::out_of_range& e) {
31240       {
31241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (std::exception& e) {
31244       {
31245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31246       };
31247     } catch (Dali::DaliException e) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31250       };
31251     } catch (...) {
31252       {
31253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31254       };
31255     }
31256   }
31257
31258   jresult = result;
31259   return jresult;
31260 }
31261
31262
31263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31264   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31265   std::string *arg2 = 0 ;
31266
31267   arg1 = (Dali::KeyEvent *)jarg1;
31268   if (!jarg2) {
31269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31270     return ;
31271   }
31272   std::string arg2_str(jarg2);
31273   arg2 = &arg2_str;
31274   if (arg1) (arg1)->keyPressedName = *arg2;
31275
31276   //argout typemap for const std::string&
31277
31278 }
31279
31280
31281 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31282   char * jresult ;
31283
31284   if( jarg1 == NULL )
31285   {
31286     jresult = SWIG_csharp_string_callback( "" );
31287   }
31288   else
31289   {
31290     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31291     std::string *result = 0;
31292
31293     arg1 = ( Dali::KeyEvent * )jarg1;
31294     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31295     jresult = SWIG_csharp_string_callback( result->c_str() );
31296   }
31297
31298   return jresult;
31299 }
31300
31301
31302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31303   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31304   std::string *arg2 = 0 ;
31305
31306   arg1 = (Dali::KeyEvent *)jarg1;
31307   if (!jarg2) {
31308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31309     return ;
31310   }
31311   std::string arg2_str(jarg2);
31312   arg2 = &arg2_str;
31313   if (arg1) (arg1)->keyPressed = *arg2;
31314
31315   //argout typemap for const std::string&
31316
31317 }
31318
31319
31320 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31321   char * jresult ;
31322   if( NULL == jarg1 )
31323   {
31324     jresult = SWIG_csharp_string_callback( "" );
31325   }
31326   else
31327   {
31328     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31329     std::string *result = 0;
31330
31331     arg1 = ( Dali::KeyEvent * )jarg1;
31332     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31333     jresult = SWIG_csharp_string_callback( result->c_str() );
31334   }
31335   return jresult;
31336 }
31337
31338
31339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31340   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31341   int arg2 ;
31342
31343   arg1 = (Dali::KeyEvent *)jarg1;
31344   arg2 = (int)jarg2;
31345   if (arg1) (arg1)->keyCode = arg2;
31346 }
31347
31348
31349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31350   int jresult ;
31351   if( NULL == jarg1 )
31352   {
31353     jresult = -1;
31354   }
31355   else
31356   {
31357     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31358     int result;
31359
31360     arg1 = ( Dali::KeyEvent * )jarg1;
31361     result = (int)( ( arg1 )->keyCode );
31362     jresult = result;
31363   }
31364   return jresult;
31365 }
31366
31367
31368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31369   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31370   int arg2 ;
31371
31372   arg1 = (Dali::KeyEvent *)jarg1;
31373   arg2 = (int)jarg2;
31374   if (arg1) (arg1)->keyModifier = arg2;
31375 }
31376
31377
31378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31379   int jresult ;
31380   if( jarg1 == NULL )
31381   {
31382     jresult = -1;
31383   }
31384   else
31385   {
31386     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31387     int result;
31388
31389     arg1 = ( Dali::KeyEvent * )jarg1;
31390     result = (int)( ( arg1 )->keyModifier );
31391     jresult = result;
31392   }
31393   return jresult;
31394 }
31395
31396
31397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31398   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31399   unsigned long arg2 ;
31400
31401   arg1 = (Dali::KeyEvent *)jarg1;
31402   arg2 = (unsigned long)jarg2;
31403   if (arg1) (arg1)->time = arg2;
31404 }
31405
31406
31407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31408   unsigned long jresult ;
31409   if( jarg1 == NULL )
31410   {
31411     jresult = 0;
31412   }
31413   else
31414   {
31415     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31416     unsigned long result;
31417
31418     arg1 = ( Dali::KeyEvent * )jarg1;
31419     result = (unsigned long)( ( arg1 )->time );
31420     jresult = (unsigned long)result;
31421   }
31422   return jresult;
31423 }
31424
31425
31426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31428   Dali::KeyEvent::State arg2 ;
31429
31430   arg1 = (Dali::KeyEvent *)jarg1;
31431   arg2 = (Dali::KeyEvent::State)jarg2;
31432   if (arg1) (arg1)->state = arg2;
31433 }
31434
31435
31436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31437   int jresult ;
31438   if( jarg1 == NULL )
31439   {
31440     jresult = -1;
31441   }
31442   else
31443   {
31444     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31445     Dali::KeyEvent::State result;
31446
31447     arg1 = ( Dali::KeyEvent * )jarg1;
31448     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31449     jresult = (int)result;
31450   }
31451   return jresult;
31452 }
31453
31454
31455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31456   void * jresult ;
31457   Dali::LongPressGestureDetector *result = 0 ;
31458
31459   {
31460     try {
31461       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31462     } catch (std::out_of_range& e) {
31463       {
31464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31465       };
31466     } catch (std::exception& e) {
31467       {
31468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31469       };
31470     } catch (Dali::DaliException e) {
31471       {
31472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31473       };
31474     } catch (...) {
31475       {
31476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31477       };
31478     }
31479   }
31480
31481   jresult = (void *)result;
31482   return jresult;
31483 }
31484
31485
31486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31487   void * jresult ;
31488   Dali::LongPressGestureDetector result;
31489
31490   {
31491     try {
31492       result = Dali::LongPressGestureDetector::New();
31493     } catch (std::out_of_range& e) {
31494       {
31495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31496       };
31497     } catch (std::exception& e) {
31498       {
31499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (Dali::DaliException e) {
31502       {
31503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31504       };
31505     } catch (...) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31508       };
31509     }
31510   }
31511
31512   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31513   return jresult;
31514 }
31515
31516
31517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31518   void * jresult ;
31519   unsigned int arg1 ;
31520   Dali::LongPressGestureDetector result;
31521
31522   arg1 = (unsigned int)jarg1;
31523   {
31524     try {
31525       result = Dali::LongPressGestureDetector::New(arg1);
31526     } catch (std::out_of_range& e) {
31527       {
31528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31529       };
31530     } catch (std::exception& e) {
31531       {
31532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31533       };
31534     } catch (Dali::DaliException e) {
31535       {
31536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31537       };
31538     } catch (...) {
31539       {
31540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31541       };
31542     }
31543   }
31544
31545   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31546   return jresult;
31547 }
31548
31549
31550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31551   void * jresult ;
31552   unsigned int arg1 ;
31553   unsigned int arg2 ;
31554   Dali::LongPressGestureDetector result;
31555
31556   arg1 = (unsigned int)jarg1;
31557   arg2 = (unsigned int)jarg2;
31558   {
31559     try {
31560       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31561     } catch (std::out_of_range& e) {
31562       {
31563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (std::exception& e) {
31566       {
31567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31568       };
31569     } catch (Dali::DaliException e) {
31570       {
31571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31572       };
31573     } catch (...) {
31574       {
31575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31576       };
31577     }
31578   }
31579
31580   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31581   return jresult;
31582 }
31583
31584
31585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31586   void * jresult ;
31587   Dali::BaseHandle arg1 ;
31588   Dali::BaseHandle *argp1 ;
31589   Dali::LongPressGestureDetector result;
31590
31591   argp1 = (Dali::BaseHandle *)jarg1;
31592   if (!argp1) {
31593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31594     return 0;
31595   }
31596   arg1 = *argp1;
31597   {
31598     try {
31599       result = Dali::LongPressGestureDetector::DownCast(arg1);
31600     } catch (std::out_of_range& e) {
31601       {
31602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31603       };
31604     } catch (std::exception& e) {
31605       {
31606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31607       };
31608     } catch (Dali::DaliException e) {
31609       {
31610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31611       };
31612     } catch (...) {
31613       {
31614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31615       };
31616     }
31617   }
31618
31619   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31620   return jresult;
31621 }
31622
31623
31624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31625   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31626
31627   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31628   {
31629     try {
31630       delete arg1;
31631     } catch (std::out_of_range& e) {
31632       {
31633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31634       };
31635     } catch (std::exception& e) {
31636       {
31637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31638       };
31639     } catch (Dali::DaliException e) {
31640       {
31641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31642       };
31643     } catch (...) {
31644       {
31645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31646       };
31647     }
31648   }
31649
31650 }
31651
31652
31653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31654   void * jresult ;
31655   Dali::LongPressGestureDetector *arg1 = 0 ;
31656   Dali::LongPressGestureDetector *result = 0 ;
31657
31658   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31659   if (!arg1) {
31660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31661     return 0;
31662   }
31663   {
31664     try {
31665       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31666     } catch (std::out_of_range& e) {
31667       {
31668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31669       };
31670     } catch (std::exception& e) {
31671       {
31672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31673       };
31674     } catch (Dali::DaliException e) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31681       };
31682     }
31683   }
31684
31685   jresult = (void *)result;
31686   return jresult;
31687 }
31688
31689
31690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31691   void * jresult ;
31692   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31693   Dali::LongPressGestureDetector *arg2 = 0 ;
31694   Dali::LongPressGestureDetector *result = 0 ;
31695
31696   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31697   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31698   if (!arg2) {
31699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31700     return 0;
31701   }
31702   {
31703     try {
31704       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31705     } catch (std::out_of_range& e) {
31706       {
31707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31708       };
31709     } catch (std::exception& e) {
31710       {
31711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31712       };
31713     } catch (Dali::DaliException e) {
31714       {
31715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31716       };
31717     } catch (...) {
31718       {
31719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31720       };
31721     }
31722   }
31723
31724   jresult = (void *)result;
31725   return jresult;
31726 }
31727
31728
31729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31730   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31731   unsigned int arg2 ;
31732
31733   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31734   arg2 = (unsigned int)jarg2;
31735   {
31736     try {
31737       (arg1)->SetTouchesRequired(arg2);
31738     } catch (std::out_of_range& e) {
31739       {
31740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31741       };
31742     } catch (std::exception& e) {
31743       {
31744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31745       };
31746     } catch (Dali::DaliException e) {
31747       {
31748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31749       };
31750     } catch (...) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31753       };
31754     }
31755   }
31756
31757 }
31758
31759
31760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31761   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31762   unsigned int arg2 ;
31763   unsigned int arg3 ;
31764
31765   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31766   arg2 = (unsigned int)jarg2;
31767   arg3 = (unsigned int)jarg3;
31768   {
31769     try {
31770       (arg1)->SetTouchesRequired(arg2,arg3);
31771     } catch (std::out_of_range& e) {
31772       {
31773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31774       };
31775     } catch (std::exception& e) {
31776       {
31777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31778       };
31779     } catch (Dali::DaliException e) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31782       };
31783     } catch (...) {
31784       {
31785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31786       };
31787     }
31788   }
31789
31790 }
31791
31792
31793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31794   unsigned int jresult ;
31795   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31796   unsigned int result;
31797
31798   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31799   {
31800     try {
31801       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31802     } catch (std::out_of_range& e) {
31803       {
31804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31805       };
31806     } catch (std::exception& e) {
31807       {
31808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31809       };
31810     } catch (Dali::DaliException e) {
31811       {
31812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31813       };
31814     } catch (...) {
31815       {
31816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31817       };
31818     }
31819   }
31820
31821   jresult = result;
31822   return jresult;
31823 }
31824
31825
31826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31827   unsigned int jresult ;
31828   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31829   unsigned int result;
31830
31831   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31832   {
31833     try {
31834       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31835     } catch (std::out_of_range& e) {
31836       {
31837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31838       };
31839     } catch (std::exception& e) {
31840       {
31841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31842       };
31843     } catch (Dali::DaliException e) {
31844       {
31845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31846       };
31847     } catch (...) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31850       };
31851     }
31852   }
31853
31854   jresult = result;
31855   return jresult;
31856 }
31857
31858
31859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31860   void * jresult ;
31861   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31862   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31863
31864   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31865   {
31866     try {
31867       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31868     } catch (std::out_of_range& e) {
31869       {
31870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (std::exception& e) {
31873       {
31874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (Dali::DaliException e) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886
31887   jresult = (void *)result;
31888   return jresult;
31889 }
31890
31891
31892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31893   void * jresult ;
31894   Dali::Gesture::State arg1 ;
31895   Dali::LongPressGesture *result = 0 ;
31896
31897   arg1 = (Dali::Gesture::State)jarg1;
31898   {
31899     try {
31900       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31901     } catch (std::out_of_range& e) {
31902       {
31903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31904       };
31905     } catch (std::exception& e) {
31906       {
31907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31908       };
31909     } catch (Dali::DaliException e) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31912       };
31913     } catch (...) {
31914       {
31915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31916       };
31917     }
31918   }
31919
31920   jresult = (void *)result;
31921   return jresult;
31922 }
31923
31924
31925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31926   void * jresult ;
31927   Dali::LongPressGesture *arg1 = 0 ;
31928   Dali::LongPressGesture *result = 0 ;
31929
31930   arg1 = (Dali::LongPressGesture *)jarg1;
31931   if (!arg1) {
31932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31933     return 0;
31934   }
31935   {
31936     try {
31937       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31938     } catch (std::out_of_range& e) {
31939       {
31940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31941       };
31942     } catch (std::exception& e) {
31943       {
31944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31945       };
31946     } catch (Dali::DaliException e) {
31947       {
31948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31949       };
31950     } catch (...) {
31951       {
31952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31953       };
31954     }
31955   }
31956
31957   jresult = (void *)result;
31958   return jresult;
31959 }
31960
31961
31962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31963   void * jresult ;
31964   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31965   Dali::LongPressGesture *arg2 = 0 ;
31966   Dali::LongPressGesture *result = 0 ;
31967
31968   arg1 = (Dali::LongPressGesture *)jarg1;
31969   arg2 = (Dali::LongPressGesture *)jarg2;
31970   if (!arg2) {
31971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31972     return 0;
31973   }
31974   {
31975     try {
31976       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31977     } catch (std::out_of_range& e) {
31978       {
31979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31980       };
31981     } catch (std::exception& e) {
31982       {
31983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31984       };
31985     } catch (Dali::DaliException e) {
31986       {
31987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31988       };
31989     } catch (...) {
31990       {
31991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31992       };
31993     }
31994   }
31995
31996   jresult = (void *)result;
31997   return jresult;
31998 }
31999
32000
32001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32002   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32003
32004   arg1 = (Dali::LongPressGesture *)jarg1;
32005   {
32006     try {
32007       delete arg1;
32008     } catch (std::out_of_range& e) {
32009       {
32010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32011       };
32012     } catch (std::exception& e) {
32013       {
32014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32015       };
32016     } catch (Dali::DaliException e) {
32017       {
32018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32019       };
32020     } catch (...) {
32021       {
32022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32023       };
32024     }
32025   }
32026
32027 }
32028
32029
32030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32031   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32032   unsigned int arg2 ;
32033
32034   arg1 = (Dali::LongPressGesture *)jarg1;
32035   arg2 = (unsigned int)jarg2;
32036   if (arg1) (arg1)->numberOfTouches = arg2;
32037 }
32038
32039
32040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32041   unsigned int jresult ;
32042   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32043   unsigned int result;
32044
32045   arg1 = (Dali::LongPressGesture *)jarg1;
32046   result = (unsigned int) ((arg1)->numberOfTouches);
32047   jresult = result;
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32053   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32054   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32055
32056   arg1 = (Dali::LongPressGesture *)jarg1;
32057   arg2 = (Dali::Vector2 *)jarg2;
32058   if (arg1) (arg1)->screenPoint = *arg2;
32059 }
32060
32061
32062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32063   void * jresult ;
32064   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32065   Dali::Vector2 *result = 0 ;
32066
32067   arg1 = (Dali::LongPressGesture *)jarg1;
32068   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32069   jresult = (void *)result;
32070   return jresult;
32071 }
32072
32073
32074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32075   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32076   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32077
32078   arg1 = (Dali::LongPressGesture *)jarg1;
32079   arg2 = (Dali::Vector2 *)jarg2;
32080   if (arg1) (arg1)->localPoint = *arg2;
32081 }
32082
32083
32084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32085   void * jresult ;
32086   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32087   Dali::Vector2 *result = 0 ;
32088
32089   arg1 = (Dali::LongPressGesture *)jarg1;
32090   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32091   jresult = (void *)result;
32092   return jresult;
32093 }
32094
32095
32096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32097   void * jresult ;
32098   Dali::WheelEvent *result = 0 ;
32099
32100   {
32101     try {
32102       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32103     } catch (std::out_of_range& e) {
32104       {
32105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32106       };
32107     } catch (std::exception& e) {
32108       {
32109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32110       };
32111     } catch (Dali::DaliException e) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32114       };
32115     } catch (...) {
32116       {
32117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32118       };
32119     }
32120   }
32121
32122   jresult = (void *)result;
32123   return jresult;
32124 }
32125
32126
32127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32128   void * jresult ;
32129   Dali::WheelEvent::Type arg1 ;
32130   int arg2 ;
32131   unsigned int arg3 ;
32132   Dali::Vector2 arg4 ;
32133   int arg5 ;
32134   unsigned int arg6 ;
32135   Dali::Vector2 *argp4 ;
32136   Dali::WheelEvent *result = 0 ;
32137
32138   arg1 = (Dali::WheelEvent::Type)jarg1;
32139   arg2 = (int)jarg2;
32140   arg3 = (unsigned int)jarg3;
32141   argp4 = (Dali::Vector2 *)jarg4;
32142   if (!argp4) {
32143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32144     return 0;
32145   }
32146   arg4 = *argp4;
32147   arg5 = (int)jarg5;
32148   arg6 = (unsigned int)jarg6;
32149   {
32150     try {
32151       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32152     } catch (std::out_of_range& e) {
32153       {
32154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32155       };
32156     } catch (std::exception& e) {
32157       {
32158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32159       };
32160     } catch (Dali::DaliException e) {
32161       {
32162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32163       };
32164     } catch (...) {
32165       {
32166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32167       };
32168     }
32169   }
32170
32171   jresult = (void *)result;
32172   return jresult;
32173 }
32174
32175
32176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32177   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32178
32179   arg1 = (Dali::WheelEvent *)jarg1;
32180   {
32181     try {
32182       delete arg1;
32183     } catch (std::out_of_range& e) {
32184       {
32185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32186       };
32187     } catch (std::exception& e) {
32188       {
32189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32190       };
32191     } catch (Dali::DaliException e) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32194       };
32195     } catch (...) {
32196       {
32197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32198       };
32199     }
32200   }
32201
32202 }
32203
32204
32205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32206   unsigned int jresult ;
32207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32208   bool result;
32209
32210   arg1 = (Dali::WheelEvent *)jarg1;
32211   {
32212     try {
32213       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32214     } catch (std::out_of_range& e) {
32215       {
32216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32217       };
32218     } catch (std::exception& e) {
32219       {
32220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32221       };
32222     } catch (Dali::DaliException e) {
32223       {
32224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32225       };
32226     } catch (...) {
32227       {
32228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32229       };
32230     }
32231   }
32232
32233   jresult = result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32239   unsigned int jresult ;
32240   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32241   bool result;
32242
32243   arg1 = (Dali::WheelEvent *)jarg1;
32244   {
32245     try {
32246       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32247     } catch (std::out_of_range& e) {
32248       {
32249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (std::exception& e) {
32252       {
32253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (Dali::DaliException e) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265
32266   jresult = result;
32267   return jresult;
32268 }
32269
32270
32271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32272   unsigned int jresult ;
32273   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32274   bool result;
32275
32276   arg1 = (Dali::WheelEvent *)jarg1;
32277   {
32278     try {
32279       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32280     } catch (std::out_of_range& e) {
32281       {
32282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32283       };
32284     } catch (std::exception& e) {
32285       {
32286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32287       };
32288     } catch (Dali::DaliException e) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32291       };
32292     } catch (...) {
32293       {
32294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32295       };
32296     }
32297   }
32298
32299   jresult = result;
32300   return jresult;
32301 }
32302
32303
32304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32305   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32306   Dali::WheelEvent::Type arg2 ;
32307
32308   arg1 = (Dali::WheelEvent *)jarg1;
32309   arg2 = (Dali::WheelEvent::Type)jarg2;
32310   if (arg1) (arg1)->type = arg2;
32311 }
32312
32313
32314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32315   int jresult ;
32316   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32317   Dali::WheelEvent::Type result;
32318
32319   arg1 = (Dali::WheelEvent *)jarg1;
32320   result = (Dali::WheelEvent::Type) ((arg1)->type);
32321   jresult = (int)result;
32322   return jresult;
32323 }
32324
32325
32326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32327   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32328   int arg2 ;
32329
32330   arg1 = (Dali::WheelEvent *)jarg1;
32331   arg2 = (int)jarg2;
32332   if (arg1) (arg1)->direction = arg2;
32333 }
32334
32335
32336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32337   int jresult ;
32338   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32339   int result;
32340
32341   arg1 = (Dali::WheelEvent *)jarg1;
32342   result = (int) ((arg1)->direction);
32343   jresult = result;
32344   return jresult;
32345 }
32346
32347
32348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32349   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32350   unsigned int arg2 ;
32351
32352   arg1 = (Dali::WheelEvent *)jarg1;
32353   arg2 = (unsigned int)jarg2;
32354   if (arg1) (arg1)->modifiers = arg2;
32355 }
32356
32357
32358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32359   unsigned int jresult ;
32360   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32361   unsigned int result;
32362
32363   arg1 = (Dali::WheelEvent *)jarg1;
32364   result = (unsigned int) ((arg1)->modifiers);
32365   jresult = result;
32366   return jresult;
32367 }
32368
32369
32370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32371   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32372   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32373
32374   arg1 = (Dali::WheelEvent *)jarg1;
32375   arg2 = (Dali::Vector2 *)jarg2;
32376   if (arg1) (arg1)->point = *arg2;
32377 }
32378
32379
32380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32381   void * jresult ;
32382   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32383   Dali::Vector2 *result = 0 ;
32384
32385   arg1 = (Dali::WheelEvent *)jarg1;
32386   result = (Dali::Vector2 *)& ((arg1)->point);
32387   jresult = (void *)result;
32388   return jresult;
32389 }
32390
32391
32392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32393   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32394   int arg2 ;
32395
32396   arg1 = (Dali::WheelEvent *)jarg1;
32397   arg2 = (int)jarg2;
32398   if (arg1) (arg1)->z = arg2;
32399 }
32400
32401
32402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32403   int jresult ;
32404   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32405   int result;
32406
32407   arg1 = (Dali::WheelEvent *)jarg1;
32408   result = (int) ((arg1)->z);
32409   jresult = result;
32410   return jresult;
32411 }
32412
32413
32414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32415   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32416   unsigned int arg2 ;
32417
32418   arg1 = (Dali::WheelEvent *)jarg1;
32419   arg2 = (unsigned int)jarg2;
32420   if (arg1) (arg1)->timeStamp = arg2;
32421 }
32422
32423
32424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32425   unsigned int jresult ;
32426   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32427   unsigned int result;
32428
32429   arg1 = (Dali::WheelEvent *)jarg1;
32430   result = (unsigned int) ((arg1)->timeStamp);
32431   jresult = result;
32432   return jresult;
32433 }
32434
32435 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32436   char * jresult ;
32437   Dali::KeyEvent *arg1 = 0 ;
32438   std::string result;
32439
32440   arg1 = (Dali::KeyEvent *)jarg1;
32441   if (!arg1) {
32442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32443     return 0;
32444   }
32445   {
32446     try {
32447       result = arg1->GetDeviceName();
32448     } catch (std::out_of_range& e) {
32449       {
32450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32451       };
32452     } catch (std::exception& e) {
32453       {
32454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32455       };
32456     } catch (Dali::DaliException e) {
32457       {
32458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32459       };
32460     } catch (...) {
32461       {
32462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32463       };
32464     }
32465   }
32466
32467   jresult = SWIG_csharp_string_callback((&result)->c_str());
32468   return jresult;
32469 }
32470
32471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32472   int jresult ;
32473   Dali::KeyEvent *arg1 = 0 ;
32474   Dali::Device::Class::Type result;
32475
32476   arg1 = (Dali::KeyEvent *)jarg1;
32477   if (!arg1) {
32478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32479     return 0;
32480   }
32481   {
32482     try {
32483       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32484     } catch (std::out_of_range& e) {
32485       {
32486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32487       };
32488     } catch (std::exception& e) {
32489       {
32490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32491       };
32492     } catch (Dali::DaliException e) {
32493       {
32494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32495       };
32496     } catch (...) {
32497       {
32498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32499       };
32500     }
32501   }
32502
32503   jresult = (int)result;
32504   return jresult;
32505 }
32506
32507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32508   int jresult ;
32509   Dali::KeyEvent *arg1 = 0 ;
32510   Dali::Device::Subclass::Type result;
32511
32512   arg1 = (Dali::KeyEvent *)jarg1;
32513   if (!arg1) {
32514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32515     return 0;
32516   }
32517   {
32518     try {
32519       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32520     } catch (std::out_of_range& e) {
32521       {
32522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32523       };
32524     } catch (std::exception& e) {
32525       {
32526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32527       };
32528     } catch (Dali::DaliException e) {
32529       {
32530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32531       };
32532     } catch (...) {
32533       {
32534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32535       };
32536     }
32537   }
32538
32539   jresult = (int)result;
32540   return jresult;
32541 }
32542
32543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32544   Dali::Actor arg1 ;
32545   Dali::Actor *argp1 ;
32546
32547   argp1 = (Dali::Actor *)jarg1;
32548   if (!argp1) {
32549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32550     return ;
32551   }
32552   arg1 = *argp1;
32553   {
32554     try {
32555       arg1.Raise();
32556     } catch (std::out_of_range& e) {
32557       {
32558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32559       };
32560     } catch (std::exception& e) {
32561       {
32562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32563       };
32564     } catch (Dali::DaliException e) {
32565       {
32566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32567       };
32568     } catch (...) {
32569       {
32570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32571       };
32572     }
32573   }
32574
32575 }
32576
32577
32578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32579   Dali::Actor arg1 ;
32580   Dali::Actor *argp1 ;
32581
32582   argp1 = (Dali::Actor *)jarg1;
32583   if (!argp1) {
32584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32585     return ;
32586   }
32587   arg1 = *argp1;
32588   {
32589     try {
32590       arg1.Lower();
32591     } catch (std::out_of_range& e) {
32592       {
32593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32594       };
32595     } catch (std::exception& e) {
32596       {
32597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32598       };
32599     } catch (Dali::DaliException e) {
32600       {
32601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32602       };
32603     } catch (...) {
32604       {
32605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32606       };
32607     }
32608   }
32609
32610 }
32611
32612
32613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32614   Dali::Actor arg1 ;
32615   Dali::Actor *argp1 ;
32616
32617   argp1 = (Dali::Actor *)jarg1;
32618   if (!argp1) {
32619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32620     return ;
32621   }
32622   arg1 = *argp1;
32623   {
32624     try {
32625       arg1.RaiseToTop();
32626     } catch (std::out_of_range& e) {
32627       {
32628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32629       };
32630     } catch (std::exception& e) {
32631       {
32632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32633       };
32634     } catch (Dali::DaliException e) {
32635       {
32636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32637       };
32638     } catch (...) {
32639       {
32640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32641       };
32642     }
32643   }
32644
32645 }
32646
32647
32648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32649   Dali::Actor arg1 ;
32650   Dali::Actor *argp1 ;
32651
32652   argp1 = (Dali::Actor *)jarg1;
32653   if (!argp1) {
32654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32655     return ;
32656   }
32657   arg1 = *argp1;
32658   {
32659     try {
32660       arg1.LowerToBottom();
32661     } catch (std::out_of_range& e) {
32662       {
32663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32664       };
32665     } catch (std::exception& e) {
32666       {
32667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32668       };
32669     } catch (Dali::DaliException e) {
32670       {
32671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32672       };
32673     } catch (...) {
32674       {
32675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32676       };
32677     }
32678   }
32679
32680 }
32681
32682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32683   Dali::Actor arg1 ;
32684   Dali::Actor arg2 ;
32685   Dali::Actor *argp1 ;
32686   Dali::Actor *argp2 ;
32687
32688   argp1 = (Dali::Actor *)jarg1;
32689   if (!argp1) {
32690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32691     return ;
32692   }
32693   arg1 = *argp1;
32694   argp2 = (Dali::Actor *)jarg2;
32695   if (!argp2) {
32696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32697     return ;
32698   }
32699   arg2 = *argp2;
32700   {
32701     try {
32702       arg1.RaiseAbove(arg2);
32703     } catch (std::out_of_range& e) {
32704       {
32705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (std::exception& e) {
32708       {
32709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32710       };
32711     } catch (Dali::DaliException e) {
32712       {
32713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32714       };
32715     } catch (...) {
32716       {
32717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32718       };
32719     }
32720   }
32721
32722 }
32723
32724
32725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32726   Dali::Actor arg1 ;
32727   Dali::Actor arg2 ;
32728   Dali::Actor *argp1 ;
32729   Dali::Actor *argp2 ;
32730
32731   argp1 = (Dali::Actor *)jarg1;
32732   if (!argp1) {
32733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32734     return ;
32735   }
32736   arg1 = *argp1;
32737   argp2 = (Dali::Actor *)jarg2;
32738   if (!argp2) {
32739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32740     return ;
32741   }
32742   arg2 = *argp2;
32743   {
32744     try {
32745       arg1.LowerBelow(arg2);
32746     } catch (std::out_of_range& e) {
32747       {
32748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32749       };
32750     } catch (std::exception& e) {
32751       {
32752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32753       };
32754     } catch (Dali::DaliException e) {
32755       {
32756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32757       };
32758     } catch (...) {
32759       {
32760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32761       };
32762     }
32763   }
32764
32765 }
32766
32767
32768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32769   void * jresult ;
32770   Dali::Actor arg1 ;
32771   Dali::Actor *argp1 ;
32772   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32773
32774   argp1 = (Dali::Actor *)jarg1;
32775   if (!argp1) {
32776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32777     return 0;
32778   }
32779   arg1 = *argp1;
32780   {
32781     try {
32782       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32783     } catch (std::out_of_range& e) {
32784       {
32785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32786       };
32787     } catch (std::exception& e) {
32788       {
32789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32790       };
32791     } catch (Dali::DaliException e) {
32792       {
32793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32794       };
32795     } catch (...) {
32796       {
32797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32798       };
32799     }
32800   }
32801
32802   jresult = (void *)result;
32803   return jresult;
32804 }
32805
32806
32807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32808   void * jresult ;
32809   Dali::Actor *arg1 ;
32810   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32811
32812   arg1 = (Dali::Actor *)jarg1;
32813   {
32814     try {
32815       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32816     } catch (std::out_of_range& e) {
32817       {
32818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32819       };
32820     } catch (std::exception& e) {
32821       {
32822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32823       };
32824     } catch (Dali::DaliException e) {
32825       {
32826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32827       };
32828     } catch (...) {
32829       {
32830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32831       };
32832     }
32833   }
32834
32835   jresult = (void *)result;
32836   return jresult;
32837 }
32838
32839
32840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32841   int jresult ;
32842   int result;
32843
32844   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32845   jresult = (int)result;
32846   return jresult;
32847 }
32848
32849
32850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32851   int jresult ;
32852   int result;
32853
32854   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32855   jresult = (int)result;
32856   return jresult;
32857 }
32858
32859
32860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32861   int jresult ;
32862   int result;
32863
32864   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32865   jresult = (int)result;
32866   return jresult;
32867 }
32868
32869
32870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32871   int jresult ;
32872   int result;
32873
32874   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32875   jresult = (int)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32881   int jresult ;
32882   int result;
32883
32884   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32885   jresult = (int)result;
32886   return jresult;
32887 }
32888
32889
32890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32891   int jresult ;
32892   int result;
32893
32894   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32895   jresult = (int)result;
32896   return jresult;
32897 }
32898
32899
32900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32901   int jresult ;
32902   int result;
32903
32904   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32905   jresult = (int)result;
32906   return jresult;
32907 }
32908
32909
32910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32911   int jresult ;
32912   int result;
32913
32914   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32915   jresult = (int)result;
32916   return jresult;
32917 }
32918
32919
32920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32921   int jresult ;
32922   int result;
32923
32924   result = (int)Dali::Actor::Property::SIZE;
32925   jresult = (int)result;
32926   return jresult;
32927 }
32928
32929
32930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32931   int jresult ;
32932   int result;
32933
32934   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32935   jresult = (int)result;
32936   return jresult;
32937 }
32938
32939
32940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32941   int jresult ;
32942   int result;
32943
32944   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32945   jresult = (int)result;
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32951   int jresult ;
32952   int result;
32953
32954   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32955   jresult = (int)result;
32956   return jresult;
32957 }
32958
32959
32960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32961   int jresult ;
32962   int result;
32963
32964   result = (int)Dali::Actor::Property::POSITION;
32965   jresult = (int)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32971   int jresult ;
32972   int result;
32973
32974   result = (int)Dali::Actor::Property::POSITION_X;
32975   jresult = (int)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32981   int jresult ;
32982   int result;
32983
32984   result = (int)Dali::Actor::Property::POSITION_Y;
32985   jresult = (int)result;
32986   return jresult;
32987 }
32988
32989
32990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32991   int jresult ;
32992   int result;
32993
32994   result = (int)Dali::Actor::Property::POSITION_Z;
32995   jresult = (int)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::WORLD_POSITION;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::ORIENTATION;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::SCALE;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::SCALE_X;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::SCALE_Y;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::SCALE_Z;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::WORLD_SCALE;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::VISIBLE;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::COLOR;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::COLOR_RED;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::COLOR_GREEN;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::COLOR_BLUE;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::WORLD_COLOR;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::NAME;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::SENSITIVE;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33231   int jresult ;
33232   int result;
33233
33234   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33235   jresult = (int)result;
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33241   int jresult ;
33242   int result;
33243
33244   result = (int)Dali::Actor::Property::COLOR_MODE;
33245   jresult = (int)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33251   int jresult ;
33252   int result;
33253
33254   result = (int)Dali::Actor::Property::DRAW_MODE;
33255   jresult = (int)result;
33256   return jresult;
33257 }
33258
33259
33260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33261   int jresult ;
33262   int result;
33263
33264   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33265   jresult = (int)result;
33266   return jresult;
33267 }
33268
33269
33270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33271   int jresult ;
33272   int result;
33273
33274   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33275   jresult = (int)result;
33276   return jresult;
33277 }
33278
33279
33280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33281   int jresult ;
33282   int result;
33283
33284   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33285   jresult = (int)result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33291   int jresult ;
33292   int result;
33293
33294   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33295   jresult = (int)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33301   int jresult ;
33302   int result;
33303
33304   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33305   jresult = (int)result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33311   int jresult ;
33312   int result;
33313
33314   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33315   jresult = (int)result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33321   int jresult ;
33322   int result;
33323
33324   result = (int)Dali::Actor::Property::PADDING;
33325   jresult = (int)result;
33326   return jresult;
33327 }
33328
33329
33330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33331   int jresult ;
33332   int result;
33333
33334   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33335   jresult = (int)result;
33336   return jresult;
33337 }
33338
33339
33340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33341   int jresult ;
33342   int result;
33343
33344   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33345   jresult = (int)result;
33346   return jresult;
33347 }
33348
33349
33350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33351   int jresult ;
33352   int result;
33353
33354   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33355   jresult = (int)result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33361   int jresult ;
33362   int result;
33363
33364   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33365   jresult = (int)result;
33366   return jresult;
33367 }
33368
33369
33370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33371   void * jresult ;
33372   Dali::Actor::Property *result = 0 ;
33373
33374   {
33375     try {
33376       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33377     } catch (std::out_of_range& e) {
33378       {
33379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33380       };
33381     } catch (std::exception& e) {
33382       {
33383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33384       };
33385     } catch (Dali::DaliException e) {
33386       {
33387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33388       };
33389     } catch (...) {
33390       {
33391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33392       };
33393     }
33394   }
33395
33396   jresult = (void *)result;
33397   return jresult;
33398 }
33399
33400
33401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33402   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33403
33404   arg1 = (Dali::Actor::Property *)jarg1;
33405   {
33406     try {
33407       delete arg1;
33408     } catch (std::out_of_range& e) {
33409       {
33410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33411       };
33412     } catch (std::exception& e) {
33413       {
33414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33415       };
33416     } catch (Dali::DaliException e) {
33417       {
33418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33419       };
33420     } catch (...) {
33421       {
33422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33423       };
33424     }
33425   }
33426
33427 }
33428
33429
33430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33431   void * jresult ;
33432   Dali::Actor *result = 0 ;
33433
33434   {
33435     try {
33436       result = (Dali::Actor *)new Dali::Actor();
33437     } catch (std::out_of_range& e) {
33438       {
33439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33440       };
33441     } catch (std::exception& e) {
33442       {
33443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33444       };
33445     } catch (Dali::DaliException e) {
33446       {
33447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33448       };
33449     } catch (...) {
33450       {
33451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33452       };
33453     }
33454   }
33455
33456   jresult = (void *)result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33462   void * jresult ;
33463   Dali::Actor result;
33464
33465   {
33466     try {
33467       result = Dali::Actor::New();
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (Dali::DaliException e) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486
33487   jresult = new Dali::Actor((const Dali::Actor &)result);
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33493   void * jresult ;
33494   Dali::BaseHandle arg1 ;
33495   Dali::BaseHandle *argp1 ;
33496   Dali::Actor result;
33497
33498   argp1 = (Dali::BaseHandle *)jarg1;
33499   if (!argp1) {
33500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33501     return 0;
33502   }
33503   arg1 = *argp1;
33504   {
33505     try {
33506       result = Dali::Actor::DownCast(arg1);
33507     } catch (std::out_of_range& e) {
33508       {
33509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33510       };
33511     } catch (std::exception& e) {
33512       {
33513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33514       };
33515     } catch (Dali::DaliException e) {
33516       {
33517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33518       };
33519     } catch (...) {
33520       {
33521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33522       };
33523     }
33524   }
33525
33526   jresult = new Dali::Actor((const Dali::Actor &)result);
33527   return jresult;
33528 }
33529
33530
33531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33533
33534   arg1 = (Dali::Actor *)jarg1;
33535   {
33536     try {
33537       delete arg1;
33538     } catch (std::out_of_range& e) {
33539       {
33540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33541       };
33542     } catch (std::exception& e) {
33543       {
33544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33545       };
33546     } catch (Dali::DaliException e) {
33547       {
33548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33549       };
33550     } catch (...) {
33551       {
33552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33553       };
33554     }
33555   }
33556
33557 }
33558
33559
33560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33561   void * jresult ;
33562   Dali::Actor *arg1 = 0 ;
33563   Dali::Actor *result = 0 ;
33564
33565   arg1 = (Dali::Actor *)jarg1;
33566   if (!arg1) {
33567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33568     return 0;
33569   }
33570   {
33571     try {
33572       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33573     } catch (std::out_of_range& e) {
33574       {
33575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33576       };
33577     } catch (std::exception& e) {
33578       {
33579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33580       };
33581     } catch (Dali::DaliException e) {
33582       {
33583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33584       };
33585     } catch (...) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33588       };
33589     }
33590   }
33591
33592   jresult = (void *)result;
33593   return jresult;
33594 }
33595
33596
33597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33598   void * jresult ;
33599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33600   Dali::Actor *arg2 = 0 ;
33601   Dali::Actor *result = 0 ;
33602
33603   arg1 = (Dali::Actor *)jarg1;
33604   arg2 = (Dali::Actor *)jarg2;
33605   if (!arg2) {
33606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33607     return 0;
33608   }
33609   {
33610     try {
33611       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33612     } catch (std::out_of_range& e) {
33613       {
33614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33615       };
33616     } catch (std::exception& e) {
33617       {
33618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33619       };
33620     } catch (Dali::DaliException e) {
33621       {
33622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33623       };
33624     } catch (...) {
33625       {
33626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33627       };
33628     }
33629   }
33630
33631   jresult = (void *)result;
33632   return jresult;
33633 }
33634
33635
33636 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33637   char * jresult ;
33638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33639   std::string *result = 0 ;
33640
33641   arg1 = (Dali::Actor *)jarg1;
33642   {
33643     try {
33644       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33645     } catch (std::out_of_range& e) {
33646       {
33647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33648       };
33649     } catch (std::exception& e) {
33650       {
33651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33652       };
33653     } catch (Dali::DaliException e) {
33654       {
33655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33656       };
33657     } catch (...) {
33658       {
33659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33660       };
33661     }
33662   }
33663
33664   jresult = SWIG_csharp_string_callback(result->c_str());
33665   return jresult;
33666 }
33667
33668
33669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33671   std::string *arg2 = 0 ;
33672
33673   arg1 = (Dali::Actor *)jarg1;
33674   if (!jarg2) {
33675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33676     return ;
33677   }
33678   std::string arg2_str(jarg2);
33679   arg2 = &arg2_str;
33680   {
33681     try {
33682       (arg1)->SetName((std::string const &)*arg2);
33683     } catch (std::out_of_range& e) {
33684       {
33685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33686       };
33687     } catch (std::exception& e) {
33688       {
33689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33690       };
33691     } catch (Dali::DaliException e) {
33692       {
33693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33694       };
33695     } catch (...) {
33696       {
33697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33698       };
33699     }
33700   }
33701
33702
33703   //argout typemap for const std::string&
33704
33705 }
33706
33707
33708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33709   unsigned int jresult ;
33710   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33711   unsigned int result;
33712
33713   arg1 = (Dali::Actor *)jarg1;
33714   {
33715     try {
33716       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33717     } catch (std::out_of_range& e) {
33718       {
33719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33720       };
33721     } catch (std::exception& e) {
33722       {
33723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33724       };
33725     } catch (Dali::DaliException e) {
33726       {
33727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33728       };
33729     } catch (...) {
33730       {
33731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33732       };
33733     }
33734   }
33735
33736   jresult = result;
33737   return jresult;
33738 }
33739
33740
33741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33742   unsigned int jresult ;
33743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33744   bool result;
33745
33746   arg1 = (Dali::Actor *)jarg1;
33747   {
33748     try {
33749       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33750     } catch (std::out_of_range& e) {
33751       {
33752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33753       };
33754     } catch (std::exception& e) {
33755       {
33756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33757       };
33758     } catch (Dali::DaliException e) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33761       };
33762     } catch (...) {
33763       {
33764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33765       };
33766     }
33767   }
33768
33769   jresult = result;
33770   return jresult;
33771 }
33772
33773
33774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33775   unsigned int jresult ;
33776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33777   bool result;
33778
33779   arg1 = (Dali::Actor *)jarg1;
33780   {
33781     try {
33782       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33783     } catch (std::out_of_range& e) {
33784       {
33785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33786       };
33787     } catch (std::exception& e) {
33788       {
33789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33790       };
33791     } catch (Dali::DaliException e) {
33792       {
33793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33794       };
33795     } catch (...) {
33796       {
33797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33798       };
33799     }
33800   }
33801
33802   jresult = result;
33803   return jresult;
33804 }
33805
33806
33807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33808   unsigned int jresult ;
33809   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33810   bool result;
33811
33812   arg1 = (Dali::Actor *)jarg1;
33813   {
33814     try {
33815       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33816     } catch (std::out_of_range& e) {
33817       {
33818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33819       };
33820     } catch (std::exception& e) {
33821       {
33822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33823       };
33824     } catch (Dali::DaliException e) {
33825       {
33826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33827       };
33828     } catch (...) {
33829       {
33830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33831       };
33832     }
33833   }
33834
33835   jresult = result;
33836   return jresult;
33837 }
33838
33839
33840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33841   void * jresult ;
33842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33843   Dali::Layer result;
33844
33845   arg1 = (Dali::Actor *)jarg1;
33846   {
33847     try {
33848       result = (arg1)->GetLayer();
33849     } catch (std::out_of_range& e) {
33850       {
33851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33852       };
33853     } catch (std::exception& e) {
33854       {
33855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33856       };
33857     } catch (Dali::DaliException e) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33860       };
33861     } catch (...) {
33862       {
33863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33864       };
33865     }
33866   }
33867
33868   jresult = new Dali::Layer((const Dali::Layer &)result);
33869   return jresult;
33870 }
33871
33872
33873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33875   Dali::Actor arg2 ;
33876   Dali::Actor *argp2 ;
33877
33878   arg1 = (Dali::Actor *)jarg1;
33879   argp2 = (Dali::Actor *)jarg2;
33880   if (!argp2) {
33881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33882     return ;
33883   }
33884   arg2 = *argp2;
33885   {
33886     try {
33887       (arg1)->Add(arg2);
33888     } catch (std::out_of_range& e) {
33889       {
33890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33891       };
33892     } catch (std::exception& e) {
33893       {
33894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33895       };
33896     } catch (Dali::DaliException e) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33899       };
33900     } catch (...) {
33901       {
33902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33903       };
33904     }
33905   }
33906
33907 }
33908
33909
33910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33912   Dali::Actor arg2 ;
33913   Dali::Actor *argp2 ;
33914
33915   arg1 = (Dali::Actor *)jarg1;
33916   argp2 = (Dali::Actor *)jarg2;
33917   if (!argp2) {
33918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33919     return ;
33920   }
33921   arg2 = *argp2;
33922   {
33923     try {
33924       (arg1)->Remove(arg2);
33925     } catch (std::out_of_range& e) {
33926       {
33927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33928       };
33929     } catch (std::exception& e) {
33930       {
33931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33932       };
33933     } catch (Dali::DaliException e) {
33934       {
33935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33936       };
33937     } catch (...) {
33938       {
33939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33940       };
33941     }
33942   }
33943
33944 }
33945
33946
33947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33948   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33949
33950   arg1 = (Dali::Actor *)jarg1;
33951   {
33952     try {
33953       (arg1)->Unparent();
33954     } catch (std::out_of_range& e) {
33955       {
33956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33957       };
33958     } catch (std::exception& e) {
33959       {
33960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33961       };
33962     } catch (Dali::DaliException e) {
33963       {
33964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33965       };
33966     } catch (...) {
33967       {
33968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33969       };
33970     }
33971   }
33972
33973 }
33974
33975
33976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33977   unsigned int jresult ;
33978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33979   unsigned int result;
33980
33981   arg1 = (Dali::Actor *)jarg1;
33982   {
33983     try {
33984       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33992       };
33993     } catch (Dali::DaliException e) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33996       };
33997     } catch (...) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34000       };
34001     }
34002   }
34003
34004   jresult = result;
34005   return jresult;
34006 }
34007
34008
34009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34010   void * jresult ;
34011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34012   unsigned int arg2 ;
34013   Dali::Actor result;
34014
34015   arg1 = (Dali::Actor *)jarg1;
34016   arg2 = (unsigned int)jarg2;
34017   {
34018     try {
34019       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34020     } catch (std::out_of_range& e) {
34021       {
34022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34023       };
34024     } catch (std::exception& e) {
34025       {
34026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34027       };
34028     } catch (Dali::DaliException e) {
34029       {
34030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34031       };
34032     } catch (...) {
34033       {
34034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34035       };
34036     }
34037   }
34038
34039   jresult = new Dali::Actor((const Dali::Actor &)result);
34040   return jresult;
34041 }
34042
34043
34044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34045   void * jresult ;
34046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34047   std::string *arg2 = 0 ;
34048   Dali::Actor result;
34049
34050   arg1 = (Dali::Actor *)jarg1;
34051   if (!jarg2) {
34052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34053     return 0;
34054   }
34055   std::string arg2_str(jarg2);
34056   arg2 = &arg2_str;
34057   {
34058     try {
34059       result = (arg1)->FindChildByName((std::string const &)*arg2);
34060     } catch (std::out_of_range& e) {
34061       {
34062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34063       };
34064     } catch (std::exception& e) {
34065       {
34066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34067       };
34068     } catch (Dali::DaliException e) {
34069       {
34070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34071       };
34072     } catch (...) {
34073       {
34074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34075       };
34076     }
34077   }
34078
34079   jresult = new Dali::Actor((const Dali::Actor &)result);
34080
34081   //argout typemap for const std::string&
34082
34083   return jresult;
34084 }
34085
34086
34087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34088   void * jresult ;
34089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34090   unsigned int arg2 ;
34091   Dali::Actor result;
34092
34093   arg1 = (Dali::Actor *)jarg1;
34094   arg2 = (unsigned int)jarg2;
34095   {
34096     try {
34097       result = (arg1)->FindChildById(arg2);
34098     } catch (std::out_of_range& e) {
34099       {
34100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34101       };
34102     } catch (std::exception& e) {
34103       {
34104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34105       };
34106     } catch (Dali::DaliException e) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34109       };
34110     } catch (...) {
34111       {
34112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34113       };
34114     }
34115   }
34116
34117   jresult = new Dali::Actor((const Dali::Actor &)result);
34118   return jresult;
34119 }
34120
34121
34122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34123   void * jresult ;
34124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34125   Dali::Actor result;
34126
34127   arg1 = (Dali::Actor *)jarg1;
34128   {
34129     try {
34130       result = ((Dali::Actor const *)arg1)->GetParent();
34131     } catch (std::out_of_range& e) {
34132       {
34133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34134       };
34135     } catch (std::exception& e) {
34136       {
34137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34138       };
34139     } catch (Dali::DaliException e) {
34140       {
34141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34142       };
34143     } catch (...) {
34144       {
34145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34146       };
34147     }
34148   }
34149
34150   jresult = new Dali::Actor((const Dali::Actor &)result);
34151   return jresult;
34152 }
34153
34154
34155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34156   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34157   Dali::Vector3 *arg2 = 0 ;
34158
34159   arg1 = (Dali::Actor *)jarg1;
34160   arg2 = (Dali::Vector3 *)jarg2;
34161   if (!arg2) {
34162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34163     return ;
34164   }
34165   {
34166     try {
34167       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34168     } catch (std::out_of_range& e) {
34169       {
34170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34171       };
34172     } catch (std::exception& e) {
34173       {
34174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34175       };
34176     } catch (Dali::DaliException e) {
34177       {
34178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34179       };
34180     } catch (...) {
34181       {
34182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34183       };
34184     }
34185   }
34186
34187 }
34188
34189
34190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34191   void * jresult ;
34192   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34193   Dali::Vector3 result;
34194
34195   arg1 = (Dali::Actor *)jarg1;
34196   {
34197     try {
34198       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34199     } catch (std::out_of_range& e) {
34200       {
34201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34202       };
34203     } catch (std::exception& e) {
34204       {
34205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34206       };
34207     } catch (Dali::DaliException e) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34210       };
34211     } catch (...) {
34212       {
34213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34214       };
34215     }
34216   }
34217
34218   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34219   return jresult;
34220 }
34221
34222
34223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34224   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34225   Dali::Vector3 *arg2 = 0 ;
34226
34227   arg1 = (Dali::Actor *)jarg1;
34228   arg2 = (Dali::Vector3 *)jarg2;
34229   if (!arg2) {
34230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34231     return ;
34232   }
34233   {
34234     try {
34235       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34236     } catch (std::out_of_range& e) {
34237       {
34238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34239       };
34240     } catch (std::exception& e) {
34241       {
34242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34243       };
34244     } catch (Dali::DaliException e) {
34245       {
34246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34247       };
34248     } catch (...) {
34249       {
34250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34251       };
34252     }
34253   }
34254
34255 }
34256
34257
34258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34259   void * jresult ;
34260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34261   Dali::Vector3 result;
34262
34263   arg1 = (Dali::Actor *)jarg1;
34264   {
34265     try {
34266       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34267     } catch (std::out_of_range& e) {
34268       {
34269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34270       };
34271     } catch (std::exception& e) {
34272       {
34273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34274       };
34275     } catch (Dali::DaliException e) {
34276       {
34277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34282       };
34283     }
34284   }
34285
34286   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34287   return jresult;
34288 }
34289
34290
34291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34292   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34293   float arg2 ;
34294   float arg3 ;
34295
34296   arg1 = (Dali::Actor *)jarg1;
34297   arg2 = (float)jarg2;
34298   arg3 = (float)jarg3;
34299   {
34300     try {
34301       (arg1)->SetSize(arg2,arg3);
34302     } catch (std::out_of_range& e) {
34303       {
34304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34305       };
34306     } catch (std::exception& e) {
34307       {
34308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34309       };
34310     } catch (Dali::DaliException e) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34313       };
34314     } catch (...) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34317       };
34318     }
34319   }
34320
34321 }
34322
34323
34324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34326   float arg2 ;
34327   float arg3 ;
34328   float arg4 ;
34329
34330   arg1 = (Dali::Actor *)jarg1;
34331   arg2 = (float)jarg2;
34332   arg3 = (float)jarg3;
34333   arg4 = (float)jarg4;
34334   {
34335     try {
34336       (arg1)->SetSize(arg2,arg3,arg4);
34337     } catch (std::out_of_range& e) {
34338       {
34339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (std::exception& e) {
34342       {
34343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34344       };
34345     } catch (Dali::DaliException e) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34348       };
34349     } catch (...) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34352       };
34353     }
34354   }
34355
34356 }
34357
34358
34359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34361   Dali::Vector2 *arg2 = 0 ;
34362
34363   arg1 = (Dali::Actor *)jarg1;
34364   arg2 = (Dali::Vector2 *)jarg2;
34365   if (!arg2) {
34366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34367     return ;
34368   }
34369   {
34370     try {
34371       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (Dali::DaliException e) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34383       };
34384     } catch (...) {
34385       {
34386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34387       };
34388     }
34389   }
34390
34391 }
34392
34393
34394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34396   Dali::Vector3 *arg2 = 0 ;
34397
34398   arg1 = (Dali::Actor *)jarg1;
34399   arg2 = (Dali::Vector3 *)jarg2;
34400   if (!arg2) {
34401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34402     return ;
34403   }
34404   {
34405     try {
34406       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34407     } catch (std::out_of_range& e) {
34408       {
34409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34410       };
34411     } catch (std::exception& e) {
34412       {
34413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34414       };
34415     } catch (Dali::DaliException e) {
34416       {
34417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34418       };
34419     } catch (...) {
34420       {
34421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34422       };
34423     }
34424   }
34425
34426 }
34427
34428
34429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34430   void * jresult ;
34431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34432   Dali::Vector3 result;
34433
34434   arg1 = (Dali::Actor *)jarg1;
34435   {
34436     try {
34437       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34438     } catch (std::out_of_range& e) {
34439       {
34440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34441       };
34442     } catch (std::exception& e) {
34443       {
34444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34445       };
34446     } catch (Dali::DaliException e) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34449       };
34450     } catch (...) {
34451       {
34452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34453       };
34454     }
34455   }
34456
34457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34458   return jresult;
34459 }
34460
34461
34462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34463   void * jresult ;
34464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34465   Dali::Vector3 result;
34466
34467   arg1 = (Dali::Actor *)jarg1;
34468   {
34469     try {
34470       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34471     } catch (std::out_of_range& e) {
34472       {
34473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34474       };
34475     } catch (std::exception& e) {
34476       {
34477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34478       };
34479     } catch (Dali::DaliException e) {
34480       {
34481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34482       };
34483     } catch (...) {
34484       {
34485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34486       };
34487     }
34488   }
34489
34490   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34491   return jresult;
34492 }
34493
34494
34495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34496   void * jresult ;
34497   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34498   Dali::Vector3 result;
34499
34500   arg1 = (Dali::Actor *)jarg1;
34501   {
34502     try {
34503       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34504     } catch (std::out_of_range& e) {
34505       {
34506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34507       };
34508     } catch (std::exception& e) {
34509       {
34510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34511       };
34512     } catch (Dali::DaliException e) {
34513       {
34514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34515       };
34516     } catch (...) {
34517       {
34518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34519       };
34520     }
34521   }
34522
34523   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34524   return jresult;
34525 }
34526
34527
34528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34529   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34530   float arg2 ;
34531   float arg3 ;
34532
34533   arg1 = (Dali::Actor *)jarg1;
34534   arg2 = (float)jarg2;
34535   arg3 = (float)jarg3;
34536   {
34537     try {
34538       (arg1)->SetPosition(arg2,arg3);
34539     } catch (std::out_of_range& e) {
34540       {
34541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34542       };
34543     } catch (std::exception& e) {
34544       {
34545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34546       };
34547     } catch (Dali::DaliException e) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34550       };
34551     } catch (...) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34554       };
34555     }
34556   }
34557
34558 }
34559
34560
34561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34563   float arg2 ;
34564   float arg3 ;
34565   float arg4 ;
34566
34567   arg1 = (Dali::Actor *)jarg1;
34568   arg2 = (float)jarg2;
34569   arg3 = (float)jarg3;
34570   arg4 = (float)jarg4;
34571   {
34572     try {
34573       (arg1)->SetPosition(arg2,arg3,arg4);
34574     } catch (std::out_of_range& e) {
34575       {
34576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34577       };
34578     } catch (std::exception& e) {
34579       {
34580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34581       };
34582     } catch (Dali::DaliException e) {
34583       {
34584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34585       };
34586     } catch (...) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34589       };
34590     }
34591   }
34592
34593 }
34594
34595
34596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34598   Dali::Vector3 *arg2 = 0 ;
34599
34600   arg1 = (Dali::Actor *)jarg1;
34601   arg2 = (Dali::Vector3 *)jarg2;
34602   if (!arg2) {
34603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34604     return ;
34605   }
34606   {
34607     try {
34608       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34609     } catch (std::out_of_range& e) {
34610       {
34611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34612       };
34613     } catch (std::exception& e) {
34614       {
34615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34616       };
34617     } catch (Dali::DaliException e) {
34618       {
34619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34620       };
34621     } catch (...) {
34622       {
34623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34624       };
34625     }
34626   }
34627
34628 }
34629
34630
34631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34633   float arg2 ;
34634
34635   arg1 = (Dali::Actor *)jarg1;
34636   arg2 = (float)jarg2;
34637   {
34638     try {
34639       (arg1)->SetX(arg2);
34640     } catch (std::out_of_range& e) {
34641       {
34642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34643       };
34644     } catch (std::exception& e) {
34645       {
34646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34647       };
34648     } catch (Dali::DaliException e) {
34649       {
34650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34651       };
34652     } catch (...) {
34653       {
34654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34655       };
34656     }
34657   }
34658
34659 }
34660
34661
34662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34664   float arg2 ;
34665
34666   arg1 = (Dali::Actor *)jarg1;
34667   arg2 = (float)jarg2;
34668   {
34669     try {
34670       (arg1)->SetY(arg2);
34671     } catch (std::out_of_range& e) {
34672       {
34673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34674       };
34675     } catch (std::exception& e) {
34676       {
34677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34678       };
34679     } catch (Dali::DaliException e) {
34680       {
34681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34686       };
34687     }
34688   }
34689
34690 }
34691
34692
34693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34695   float arg2 ;
34696
34697   arg1 = (Dali::Actor *)jarg1;
34698   arg2 = (float)jarg2;
34699   {
34700     try {
34701       (arg1)->SetZ(arg2);
34702     } catch (std::out_of_range& e) {
34703       {
34704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34705       };
34706     } catch (std::exception& e) {
34707       {
34708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (Dali::DaliException e) {
34711       {
34712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34713       };
34714     } catch (...) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34717       };
34718     }
34719   }
34720
34721 }
34722
34723
34724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34726   Dali::Vector3 *arg2 = 0 ;
34727
34728   arg1 = (Dali::Actor *)jarg1;
34729   arg2 = (Dali::Vector3 *)jarg2;
34730   if (!arg2) {
34731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34732     return ;
34733   }
34734   {
34735     try {
34736       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (Dali::DaliException e) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34748       };
34749     } catch (...) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34752       };
34753     }
34754   }
34755
34756 }
34757
34758
34759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34760   void * jresult ;
34761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34762   Dali::Vector3 result;
34763
34764   arg1 = (Dali::Actor *)jarg1;
34765   {
34766     try {
34767       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34768     } catch (std::out_of_range& e) {
34769       {
34770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34771       };
34772     } catch (std::exception& e) {
34773       {
34774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34775       };
34776     } catch (Dali::DaliException e) {
34777       {
34778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34779       };
34780     } catch (...) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34783       };
34784     }
34785   }
34786
34787   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34788   return jresult;
34789 }
34790
34791
34792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34793   void * jresult ;
34794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34795   Dali::Vector3 result;
34796
34797   arg1 = (Dali::Actor *)jarg1;
34798   {
34799     try {
34800       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34801     } catch (std::out_of_range& e) {
34802       {
34803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34804       };
34805     } catch (std::exception& e) {
34806       {
34807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34808       };
34809     } catch (Dali::DaliException e) {
34810       {
34811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34812       };
34813     } catch (...) {
34814       {
34815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34816       };
34817     }
34818   }
34819
34820   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34821   return jresult;
34822 }
34823
34824
34825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34826   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34827   bool arg2 ;
34828
34829   arg1 = (Dali::Actor *)jarg1;
34830   arg2 = jarg2 ? true : false;
34831   {
34832     try {
34833       (arg1)->SetInheritPosition(arg2);
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34841       };
34842     } catch (Dali::DaliException e) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34845       };
34846     } catch (...) {
34847       {
34848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34849       };
34850     }
34851   }
34852
34853 }
34854
34855
34856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34857   unsigned int jresult ;
34858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34859   bool result;
34860
34861   arg1 = (Dali::Actor *)jarg1;
34862   {
34863     try {
34864       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34865     } catch (std::out_of_range& e) {
34866       {
34867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34868       };
34869     } catch (std::exception& e) {
34870       {
34871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34872       };
34873     } catch (Dali::DaliException e) {
34874       {
34875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34876       };
34877     } catch (...) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34880       };
34881     }
34882   }
34883
34884   jresult = result;
34885   return jresult;
34886 }
34887
34888
34889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34890   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34891   Dali::Degree *arg2 = 0 ;
34892   Dali::Vector3 *arg3 = 0 ;
34893
34894   arg1 = (Dali::Actor *)jarg1;
34895   arg2 = (Dali::Degree *)jarg2;
34896   if (!arg2) {
34897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34898     return ;
34899   }
34900   arg3 = (Dali::Vector3 *)jarg3;
34901   if (!arg3) {
34902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34903     return ;
34904   }
34905   {
34906     try {
34907       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34908     } catch (std::out_of_range& e) {
34909       {
34910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34911       };
34912     } catch (std::exception& e) {
34913       {
34914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34915       };
34916     } catch (Dali::DaliException e) {
34917       {
34918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34919       };
34920     } catch (...) {
34921       {
34922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34923       };
34924     }
34925   }
34926
34927 }
34928
34929
34930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34931   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34932   Dali::Radian *arg2 = 0 ;
34933   Dali::Vector3 *arg3 = 0 ;
34934
34935   arg1 = (Dali::Actor *)jarg1;
34936   arg2 = (Dali::Radian *)jarg2;
34937   if (!arg2) {
34938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34939     return ;
34940   }
34941   arg3 = (Dali::Vector3 *)jarg3;
34942   if (!arg3) {
34943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34944     return ;
34945   }
34946   {
34947     try {
34948       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34949     } catch (std::out_of_range& e) {
34950       {
34951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34952       };
34953     } catch (std::exception& e) {
34954       {
34955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34956       };
34957     } catch (Dali::DaliException e) {
34958       {
34959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34960       };
34961     } catch (...) {
34962       {
34963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34964       };
34965     }
34966   }
34967
34968 }
34969
34970
34971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34972   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34973   Dali::Quaternion *arg2 = 0 ;
34974
34975   arg1 = (Dali::Actor *)jarg1;
34976   arg2 = (Dali::Quaternion *)jarg2;
34977   if (!arg2) {
34978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34979     return ;
34980   }
34981   {
34982     try {
34983       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34984     } catch (std::out_of_range& e) {
34985       {
34986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34987       };
34988     } catch (std::exception& e) {
34989       {
34990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34991       };
34992     } catch (Dali::DaliException e) {
34993       {
34994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34995       };
34996     } catch (...) {
34997       {
34998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34999       };
35000     }
35001   }
35002
35003 }
35004
35005
35006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35008   Dali::Degree *arg2 = 0 ;
35009   Dali::Vector3 *arg3 = 0 ;
35010
35011   arg1 = (Dali::Actor *)jarg1;
35012   arg2 = (Dali::Degree *)jarg2;
35013   if (!arg2) {
35014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35015     return ;
35016   }
35017   arg3 = (Dali::Vector3 *)jarg3;
35018   if (!arg3) {
35019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35020     return ;
35021   }
35022   {
35023     try {
35024       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35025     } catch (std::out_of_range& e) {
35026       {
35027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35028       };
35029     } catch (std::exception& e) {
35030       {
35031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35032       };
35033     } catch (Dali::DaliException e) {
35034       {
35035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35036       };
35037     } catch (...) {
35038       {
35039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35040       };
35041     }
35042   }
35043
35044 }
35045
35046
35047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35049   Dali::Radian *arg2 = 0 ;
35050   Dali::Vector3 *arg3 = 0 ;
35051
35052   arg1 = (Dali::Actor *)jarg1;
35053   arg2 = (Dali::Radian *)jarg2;
35054   if (!arg2) {
35055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35056     return ;
35057   }
35058   arg3 = (Dali::Vector3 *)jarg3;
35059   if (!arg3) {
35060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35061     return ;
35062   }
35063   {
35064     try {
35065       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35066     } catch (std::out_of_range& e) {
35067       {
35068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35069       };
35070     } catch (std::exception& e) {
35071       {
35072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35073       };
35074     } catch (Dali::DaliException e) {
35075       {
35076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35077       };
35078     } catch (...) {
35079       {
35080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35081       };
35082     }
35083   }
35084
35085 }
35086
35087
35088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35090   Dali::Quaternion *arg2 = 0 ;
35091
35092   arg1 = (Dali::Actor *)jarg1;
35093   arg2 = (Dali::Quaternion *)jarg2;
35094   if (!arg2) {
35095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35096     return ;
35097   }
35098   {
35099     try {
35100       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35101     } catch (std::out_of_range& e) {
35102       {
35103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35104       };
35105     } catch (std::exception& e) {
35106       {
35107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35108       };
35109     } catch (Dali::DaliException e) {
35110       {
35111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35112       };
35113     } catch (...) {
35114       {
35115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35116       };
35117     }
35118   }
35119
35120 }
35121
35122
35123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35124   void * jresult ;
35125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35126   Dali::Quaternion result;
35127
35128   arg1 = (Dali::Actor *)jarg1;
35129   {
35130     try {
35131       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35132     } catch (std::out_of_range& e) {
35133       {
35134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35135       };
35136     } catch (std::exception& e) {
35137       {
35138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35139       };
35140     } catch (Dali::DaliException e) {
35141       {
35142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35143       };
35144     } catch (...) {
35145       {
35146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35147       };
35148     }
35149   }
35150
35151   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35152   return jresult;
35153 }
35154
35155
35156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35158   bool arg2 ;
35159
35160   arg1 = (Dali::Actor *)jarg1;
35161   arg2 = jarg2 ? true : false;
35162   {
35163     try {
35164       (arg1)->SetInheritOrientation(arg2);
35165     } catch (std::out_of_range& e) {
35166       {
35167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35168       };
35169     } catch (std::exception& e) {
35170       {
35171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35172       };
35173     } catch (Dali::DaliException e) {
35174       {
35175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35176       };
35177     } catch (...) {
35178       {
35179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35180       };
35181     }
35182   }
35183
35184 }
35185
35186
35187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35188   unsigned int jresult ;
35189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35190   bool result;
35191
35192   arg1 = (Dali::Actor *)jarg1;
35193   {
35194     try {
35195       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35196     } catch (std::out_of_range& e) {
35197       {
35198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35199       };
35200     } catch (std::exception& e) {
35201       {
35202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35203       };
35204     } catch (Dali::DaliException e) {
35205       {
35206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35207       };
35208     } catch (...) {
35209       {
35210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35211       };
35212     }
35213   }
35214
35215   jresult = result;
35216   return jresult;
35217 }
35218
35219
35220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35221   void * jresult ;
35222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35223   Dali::Quaternion result;
35224
35225   arg1 = (Dali::Actor *)jarg1;
35226   {
35227     try {
35228       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35229     } catch (std::out_of_range& e) {
35230       {
35231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (std::exception& e) {
35234       {
35235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35236       };
35237     } catch (Dali::DaliException e) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35240       };
35241     } catch (...) {
35242       {
35243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35244       };
35245     }
35246   }
35247
35248   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35249   return jresult;
35250 }
35251
35252
35253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35255   float arg2 ;
35256
35257   arg1 = (Dali::Actor *)jarg1;
35258   arg2 = (float)jarg2;
35259   {
35260     try {
35261       (arg1)->SetScale(arg2);
35262     } catch (std::out_of_range& e) {
35263       {
35264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (std::exception& e) {
35267       {
35268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35269       };
35270     } catch (Dali::DaliException e) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35273       };
35274     } catch (...) {
35275       {
35276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35277       };
35278     }
35279   }
35280
35281 }
35282
35283
35284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35286   float arg2 ;
35287   float arg3 ;
35288   float arg4 ;
35289
35290   arg1 = (Dali::Actor *)jarg1;
35291   arg2 = (float)jarg2;
35292   arg3 = (float)jarg3;
35293   arg4 = (float)jarg4;
35294   {
35295     try {
35296       (arg1)->SetScale(arg2,arg3,arg4);
35297     } catch (std::out_of_range& e) {
35298       {
35299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35300       };
35301     } catch (std::exception& e) {
35302       {
35303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35304       };
35305     } catch (Dali::DaliException e) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35308       };
35309     } catch (...) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35312       };
35313     }
35314   }
35315
35316 }
35317
35318
35319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35320   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35321   Dali::Vector3 *arg2 = 0 ;
35322
35323   arg1 = (Dali::Actor *)jarg1;
35324   arg2 = (Dali::Vector3 *)jarg2;
35325   if (!arg2) {
35326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35327     return ;
35328   }
35329   {
35330     try {
35331       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35332     } catch (std::out_of_range& e) {
35333       {
35334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35335       };
35336     } catch (std::exception& e) {
35337       {
35338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35339       };
35340     } catch (Dali::DaliException e) {
35341       {
35342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35343       };
35344     } catch (...) {
35345       {
35346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35347       };
35348     }
35349   }
35350
35351 }
35352
35353
35354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35356   Dali::Vector3 *arg2 = 0 ;
35357
35358   arg1 = (Dali::Actor *)jarg1;
35359   arg2 = (Dali::Vector3 *)jarg2;
35360   if (!arg2) {
35361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35362     return ;
35363   }
35364   {
35365     try {
35366       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35367     } catch (std::out_of_range& e) {
35368       {
35369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35370       };
35371     } catch (std::exception& e) {
35372       {
35373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35374       };
35375     } catch (Dali::DaliException e) {
35376       {
35377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35378       };
35379     } catch (...) {
35380       {
35381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35382       };
35383     }
35384   }
35385
35386 }
35387
35388
35389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35390   void * jresult ;
35391   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35392   Dali::Vector3 result;
35393
35394   arg1 = (Dali::Actor *)jarg1;
35395   {
35396     try {
35397       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35398     } catch (std::out_of_range& e) {
35399       {
35400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35401       };
35402     } catch (std::exception& e) {
35403       {
35404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35405       };
35406     } catch (Dali::DaliException e) {
35407       {
35408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35409       };
35410     } catch (...) {
35411       {
35412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35413       };
35414     }
35415   }
35416
35417   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35418   return jresult;
35419 }
35420
35421
35422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35423   void * jresult ;
35424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35425   Dali::Vector3 result;
35426
35427   arg1 = (Dali::Actor *)jarg1;
35428   {
35429     try {
35430       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35431     } catch (std::out_of_range& e) {
35432       {
35433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35434       };
35435     } catch (std::exception& e) {
35436       {
35437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35438       };
35439     } catch (Dali::DaliException e) {
35440       {
35441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35442       };
35443     } catch (...) {
35444       {
35445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35446       };
35447     }
35448   }
35449
35450   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35451   return jresult;
35452 }
35453
35454
35455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35456   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35457   bool arg2 ;
35458
35459   arg1 = (Dali::Actor *)jarg1;
35460   arg2 = jarg2 ? true : false;
35461   {
35462     try {
35463       (arg1)->SetInheritScale(arg2);
35464     } catch (std::out_of_range& e) {
35465       {
35466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35467       };
35468     } catch (std::exception& e) {
35469       {
35470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35471       };
35472     } catch (Dali::DaliException e) {
35473       {
35474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35475       };
35476     } catch (...) {
35477       {
35478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35479       };
35480     }
35481   }
35482
35483 }
35484
35485
35486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35487   unsigned int jresult ;
35488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35489   bool result;
35490
35491   arg1 = (Dali::Actor *)jarg1;
35492   {
35493     try {
35494       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35495     } catch (std::out_of_range& e) {
35496       {
35497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35498       };
35499     } catch (std::exception& e) {
35500       {
35501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35502       };
35503     } catch (Dali::DaliException e) {
35504       {
35505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35506       };
35507     } catch (...) {
35508       {
35509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35510       };
35511     }
35512   }
35513
35514   jresult = result;
35515   return jresult;
35516 }
35517
35518
35519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35520   void * jresult ;
35521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35522   Dali::Matrix result;
35523
35524   arg1 = (Dali::Actor *)jarg1;
35525   {
35526     try {
35527       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35528     } catch (std::out_of_range& e) {
35529       {
35530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35531       };
35532     } catch (std::exception& e) {
35533       {
35534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35535       };
35536     } catch (Dali::DaliException e) {
35537       {
35538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35539       };
35540     } catch (...) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35543       };
35544     }
35545   }
35546
35547   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35548   return jresult;
35549 }
35550
35551
35552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35554   bool arg2 ;
35555
35556   arg1 = (Dali::Actor *)jarg1;
35557   arg2 = jarg2 ? true : false;
35558   {
35559     try {
35560       (arg1)->SetVisible(arg2);
35561     } catch (std::out_of_range& e) {
35562       {
35563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35564       };
35565     } catch (std::exception& e) {
35566       {
35567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35568       };
35569     } catch (Dali::DaliException e) {
35570       {
35571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35572       };
35573     } catch (...) {
35574       {
35575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35576       };
35577     }
35578   }
35579
35580 }
35581
35582
35583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35584   unsigned int jresult ;
35585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35586   bool result;
35587
35588   arg1 = (Dali::Actor *)jarg1;
35589   {
35590     try {
35591       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35592     } catch (std::out_of_range& e) {
35593       {
35594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35595       };
35596     } catch (std::exception& e) {
35597       {
35598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35599       };
35600     } catch (Dali::DaliException e) {
35601       {
35602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35603       };
35604     } catch (...) {
35605       {
35606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35607       };
35608     }
35609   }
35610
35611   jresult = result;
35612   return jresult;
35613 }
35614
35615
35616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35618   float arg2 ;
35619
35620   arg1 = (Dali::Actor *)jarg1;
35621   arg2 = (float)jarg2;
35622   {
35623     try {
35624       (arg1)->SetOpacity(arg2);
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (Dali::DaliException e) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35636       };
35637     } catch (...) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35640       };
35641     }
35642   }
35643
35644 }
35645
35646
35647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35648   float jresult ;
35649   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35650   float result;
35651
35652   arg1 = (Dali::Actor *)jarg1;
35653   {
35654     try {
35655       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35656     } catch (std::out_of_range& e) {
35657       {
35658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35659       };
35660     } catch (std::exception& e) {
35661       {
35662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35663       };
35664     } catch (Dali::DaliException e) {
35665       {
35666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35667       };
35668     } catch (...) {
35669       {
35670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35671       };
35672     }
35673   }
35674
35675   jresult = result;
35676   return jresult;
35677 }
35678
35679
35680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35681   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35682   Dali::Vector4 *arg2 = 0 ;
35683
35684   arg1 = (Dali::Actor *)jarg1;
35685   arg2 = (Dali::Vector4 *)jarg2;
35686   if (!arg2) {
35687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35688     return ;
35689   }
35690   {
35691     try {
35692       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35693     } catch (std::out_of_range& e) {
35694       {
35695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35696       };
35697     } catch (std::exception& e) {
35698       {
35699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35700       };
35701     } catch (Dali::DaliException e) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35704       };
35705     } catch (...) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35708       };
35709     }
35710   }
35711
35712 }
35713
35714
35715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35716   void * jresult ;
35717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35718   Dali::Vector4 result;
35719
35720   arg1 = (Dali::Actor *)jarg1;
35721   {
35722     try {
35723       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35724     } catch (std::out_of_range& e) {
35725       {
35726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35727       };
35728     } catch (std::exception& e) {
35729       {
35730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35731       };
35732     } catch (Dali::DaliException e) {
35733       {
35734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35735       };
35736     } catch (...) {
35737       {
35738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35739       };
35740     }
35741   }
35742
35743   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35744   return jresult;
35745 }
35746
35747
35748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35750   Dali::ColorMode arg2 ;
35751
35752   arg1 = (Dali::Actor *)jarg1;
35753   arg2 = (Dali::ColorMode)jarg2;
35754   {
35755     try {
35756       (arg1)->SetColorMode(arg2);
35757     } catch (std::out_of_range& e) {
35758       {
35759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35760       };
35761     } catch (std::exception& e) {
35762       {
35763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35764       };
35765     } catch (Dali::DaliException e) {
35766       {
35767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35768       };
35769     } catch (...) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35772       };
35773     }
35774   }
35775
35776 }
35777
35778
35779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35780   int jresult ;
35781   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35782   Dali::ColorMode result;
35783
35784   arg1 = (Dali::Actor *)jarg1;
35785   {
35786     try {
35787       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35788     } catch (std::out_of_range& e) {
35789       {
35790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35791       };
35792     } catch (std::exception& e) {
35793       {
35794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35795       };
35796     } catch (Dali::DaliException e) {
35797       {
35798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35799       };
35800     } catch (...) {
35801       {
35802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35803       };
35804     }
35805   }
35806
35807   jresult = (int)result;
35808   return jresult;
35809 }
35810
35811
35812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35813   void * jresult ;
35814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35815   Dali::Vector4 result;
35816
35817   arg1 = (Dali::Actor *)jarg1;
35818   {
35819     try {
35820       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35821     } catch (std::out_of_range& e) {
35822       {
35823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35824       };
35825     } catch (std::exception& e) {
35826       {
35827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35828       };
35829     } catch (Dali::DaliException e) {
35830       {
35831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35832       };
35833     } catch (...) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35836       };
35837     }
35838   }
35839
35840   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35841   return jresult;
35842 }
35843
35844
35845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35847   Dali::DrawMode::Type arg2 ;
35848
35849   arg1 = (Dali::Actor *)jarg1;
35850   arg2 = (Dali::DrawMode::Type)jarg2;
35851   {
35852     try {
35853       (arg1)->SetDrawMode(arg2);
35854     } catch (std::out_of_range& e) {
35855       {
35856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35857       };
35858     } catch (std::exception& e) {
35859       {
35860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35861       };
35862     } catch (Dali::DaliException e) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35865       };
35866     } catch (...) {
35867       {
35868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35869       };
35870     }
35871   }
35872
35873 }
35874
35875
35876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35877   int jresult ;
35878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35879   Dali::DrawMode::Type result;
35880
35881   arg1 = (Dali::Actor *)jarg1;
35882   {
35883     try {
35884       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35885     } catch (std::out_of_range& e) {
35886       {
35887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (std::exception& e) {
35890       {
35891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (Dali::DaliException e) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35896       };
35897     } catch (...) {
35898       {
35899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35900       };
35901     }
35902   }
35903
35904   jresult = (int)result;
35905   return jresult;
35906 }
35907
35908
35909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35911   bool arg2 ;
35912
35913   arg1 = (Dali::Actor *)jarg1;
35914   arg2 = jarg2 ? true : false;
35915   {
35916     try {
35917       (arg1)->SetSensitive(arg2);
35918     } catch (std::out_of_range& e) {
35919       {
35920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35921       };
35922     } catch (std::exception& e) {
35923       {
35924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35925       };
35926     } catch (Dali::DaliException e) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35929       };
35930     } catch (...) {
35931       {
35932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35933       };
35934     }
35935   }
35936
35937 }
35938
35939
35940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35941   unsigned int jresult ;
35942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35943   bool result;
35944
35945   arg1 = (Dali::Actor *)jarg1;
35946   {
35947     try {
35948       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35949     } catch (std::out_of_range& e) {
35950       {
35951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35952       };
35953     } catch (std::exception& e) {
35954       {
35955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (Dali::DaliException e) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35960       };
35961     } catch (...) {
35962       {
35963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35964       };
35965     }
35966   }
35967
35968   jresult = result;
35969   return jresult;
35970 }
35971
35972
35973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35974   unsigned int jresult ;
35975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35976   float *arg2 = 0 ;
35977   float *arg3 = 0 ;
35978   float arg4 ;
35979   float arg5 ;
35980   bool result;
35981
35982   arg1 = (Dali::Actor *)jarg1;
35983   arg2 = (float *)jarg2;
35984   arg3 = (float *)jarg3;
35985   arg4 = (float)jarg4;
35986   arg5 = (float)jarg5;
35987   {
35988     try {
35989       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35990     } catch (std::out_of_range& e) {
35991       {
35992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35993       };
35994     } catch (std::exception& e) {
35995       {
35996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35997       };
35998     } catch (Dali::DaliException e) {
35999       {
36000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36001       };
36002     } catch (...) {
36003       {
36004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36005       };
36006     }
36007   }
36008
36009   jresult = result;
36010   return jresult;
36011 }
36012
36013
36014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36016   bool arg2 ;
36017
36018   arg1 = (Dali::Actor *)jarg1;
36019   arg2 = jarg2 ? true : false;
36020   {
36021     try {
36022       (arg1)->SetLeaveRequired(arg2);
36023     } catch (std::out_of_range& e) {
36024       {
36025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36026       };
36027     } catch (std::exception& e) {
36028       {
36029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36030       };
36031     } catch (Dali::DaliException e) {
36032       {
36033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36034       };
36035     } catch (...) {
36036       {
36037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36038       };
36039     }
36040   }
36041
36042 }
36043
36044
36045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36046   unsigned int jresult ;
36047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36048   bool result;
36049
36050   arg1 = (Dali::Actor *)jarg1;
36051   {
36052     try {
36053       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36054     } catch (std::out_of_range& e) {
36055       {
36056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36057       };
36058     } catch (std::exception& e) {
36059       {
36060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36061       };
36062     } catch (Dali::DaliException e) {
36063       {
36064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36065       };
36066     } catch (...) {
36067       {
36068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36069       };
36070     }
36071   }
36072
36073   jresult = result;
36074   return jresult;
36075 }
36076
36077
36078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36080   bool arg2 ;
36081
36082   arg1 = (Dali::Actor *)jarg1;
36083   arg2 = jarg2 ? true : false;
36084   {
36085     try {
36086       (arg1)->SetKeyboardFocusable(arg2);
36087     } catch (std::out_of_range& e) {
36088       {
36089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36090       };
36091     } catch (std::exception& e) {
36092       {
36093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36094       };
36095     } catch (Dali::DaliException e) {
36096       {
36097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36098       };
36099     } catch (...) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36102       };
36103     }
36104   }
36105
36106 }
36107
36108
36109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36110   unsigned int jresult ;
36111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36112   bool result;
36113
36114   arg1 = (Dali::Actor *)jarg1;
36115   {
36116     try {
36117       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36118     } catch (std::out_of_range& e) {
36119       {
36120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36121       };
36122     } catch (std::exception& e) {
36123       {
36124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36125       };
36126     } catch (Dali::DaliException e) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36129       };
36130     } catch (...) {
36131       {
36132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36133       };
36134     }
36135   }
36136
36137   jresult = result;
36138   return jresult;
36139 }
36140
36141
36142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36144   Dali::ResizePolicy::Type arg2 ;
36145   Dali::Dimension::Type arg3 ;
36146
36147   arg1 = (Dali::Actor *)jarg1;
36148   arg2 = (Dali::ResizePolicy::Type)jarg2;
36149   arg3 = (Dali::Dimension::Type)jarg3;
36150   {
36151     try {
36152       (arg1)->SetResizePolicy(arg2,arg3);
36153     } catch (std::out_of_range& e) {
36154       {
36155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36156       };
36157     } catch (std::exception& e) {
36158       {
36159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36160       };
36161     } catch (Dali::DaliException e) {
36162       {
36163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36164       };
36165     } catch (...) {
36166       {
36167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36168       };
36169     }
36170   }
36171
36172 }
36173
36174
36175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36176   int jresult ;
36177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36178   Dali::Dimension::Type arg2 ;
36179   Dali::ResizePolicy::Type result;
36180
36181   arg1 = (Dali::Actor *)jarg1;
36182   arg2 = (Dali::Dimension::Type)jarg2;
36183   {
36184     try {
36185       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36186     } catch (std::out_of_range& e) {
36187       {
36188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36189       };
36190     } catch (std::exception& e) {
36191       {
36192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36193       };
36194     } catch (Dali::DaliException e) {
36195       {
36196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36197       };
36198     } catch (...) {
36199       {
36200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36201       };
36202     }
36203   }
36204
36205   jresult = (int)result;
36206   return jresult;
36207 }
36208
36209
36210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36212   Dali::SizeScalePolicy::Type arg2 ;
36213
36214   arg1 = (Dali::Actor *)jarg1;
36215   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36216   {
36217     try {
36218       (arg1)->SetSizeScalePolicy(arg2);
36219     } catch (std::out_of_range& e) {
36220       {
36221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36222       };
36223     } catch (std::exception& e) {
36224       {
36225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36226       };
36227     } catch (Dali::DaliException e) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36230       };
36231     } catch (...) {
36232       {
36233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36234       };
36235     }
36236   }
36237
36238 }
36239
36240
36241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36242   int jresult ;
36243   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36244   Dali::SizeScalePolicy::Type result;
36245
36246   arg1 = (Dali::Actor *)jarg1;
36247   {
36248     try {
36249       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36250     } catch (std::out_of_range& e) {
36251       {
36252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36253       };
36254     } catch (std::exception& e) {
36255       {
36256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36257       };
36258     } catch (Dali::DaliException e) {
36259       {
36260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36261       };
36262     } catch (...) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36265       };
36266     }
36267   }
36268
36269   jresult = (int)result;
36270   return jresult;
36271 }
36272
36273
36274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36276   Dali::Vector3 *arg2 = 0 ;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   arg2 = (Dali::Vector3 *)jarg2;
36280   if (!arg2) {
36281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36282     return ;
36283   }
36284   {
36285     try {
36286       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36294       };
36295     } catch (Dali::DaliException e) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36298       };
36299     } catch (...) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36302       };
36303     }
36304   }
36305
36306 }
36307
36308
36309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36310   void * jresult ;
36311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36312   Dali::Vector3 result;
36313
36314   arg1 = (Dali::Actor *)jarg1;
36315   {
36316     try {
36317       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36318     } catch (std::out_of_range& e) {
36319       {
36320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36321       };
36322     } catch (std::exception& e) {
36323       {
36324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36325       };
36326     } catch (Dali::DaliException e) {
36327       {
36328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36329       };
36330     } catch (...) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36333       };
36334     }
36335   }
36336
36337   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36338   return jresult;
36339 }
36340
36341
36342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36343   float jresult ;
36344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36345   float arg2 ;
36346   float result;
36347
36348   arg1 = (Dali::Actor *)jarg1;
36349   arg2 = (float)jarg2;
36350   {
36351     try {
36352       result = (float)(arg1)->GetHeightForWidth(arg2);
36353     } catch (std::out_of_range& e) {
36354       {
36355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36356       };
36357     } catch (std::exception& e) {
36358       {
36359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (Dali::DaliException e) {
36362       {
36363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371
36372   jresult = result;
36373   return jresult;
36374 }
36375
36376
36377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36378   float jresult ;
36379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36380   float arg2 ;
36381   float result;
36382
36383   arg1 = (Dali::Actor *)jarg1;
36384   arg2 = (float)jarg2;
36385   {
36386     try {
36387       result = (float)(arg1)->GetWidthForHeight(arg2);
36388     } catch (std::out_of_range& e) {
36389       {
36390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (std::exception& e) {
36393       {
36394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (Dali::DaliException e) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406
36407   jresult = result;
36408   return jresult;
36409 }
36410
36411
36412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36413   float jresult ;
36414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36415   Dali::Dimension::Type arg2 ;
36416   float result;
36417
36418   arg1 = (Dali::Actor *)jarg1;
36419   arg2 = (Dali::Dimension::Type)jarg2;
36420   {
36421     try {
36422       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36423     } catch (std::out_of_range& e) {
36424       {
36425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (std::exception& e) {
36428       {
36429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36430       };
36431     } catch (Dali::DaliException e) {
36432       {
36433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36434       };
36435     } catch (...) {
36436       {
36437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36438       };
36439     }
36440   }
36441
36442   jresult = result;
36443   return jresult;
36444 }
36445
36446
36447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36448   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36449   Dali::Padding *arg2 = 0 ;
36450
36451   arg1 = (Dali::Actor *)jarg1;
36452   arg2 = (Dali::Padding *)jarg2;
36453   if (!arg2) {
36454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36455     return ;
36456   }
36457   {
36458     try {
36459       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36460     } catch (std::out_of_range& e) {
36461       {
36462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36463       };
36464     } catch (std::exception& e) {
36465       {
36466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36467       };
36468     } catch (Dali::DaliException e) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36471       };
36472     } catch (...) {
36473       {
36474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36475       };
36476     }
36477   }
36478
36479 }
36480
36481
36482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36483   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36484   Dali::Padding *arg2 = 0 ;
36485
36486   arg1 = (Dali::Actor *)jarg1;
36487   arg2 = (Dali::Padding *)jarg2;
36488   if (!arg2) {
36489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36490     return ;
36491   }
36492   {
36493     try {
36494       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36495     } catch (std::out_of_range& e) {
36496       {
36497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36498       };
36499     } catch (std::exception& e) {
36500       {
36501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36502       };
36503     } catch (Dali::DaliException e) {
36504       {
36505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36506       };
36507     } catch (...) {
36508       {
36509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36510       };
36511     }
36512   }
36513
36514 }
36515
36516
36517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36519   Dali::Vector2 *arg2 = 0 ;
36520
36521   arg1 = (Dali::Actor *)jarg1;
36522   arg2 = (Dali::Vector2 *)jarg2;
36523   if (!arg2) {
36524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36525     return ;
36526   }
36527   {
36528     try {
36529       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36530     } catch (std::out_of_range& e) {
36531       {
36532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36533       };
36534     } catch (std::exception& e) {
36535       {
36536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36537       };
36538     } catch (Dali::DaliException e) {
36539       {
36540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36541       };
36542     } catch (...) {
36543       {
36544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36545       };
36546     }
36547   }
36548
36549 }
36550
36551
36552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36553   void * jresult ;
36554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36555   Dali::Vector2 result;
36556
36557   arg1 = (Dali::Actor *)jarg1;
36558   {
36559     try {
36560       result = (arg1)->GetMinimumSize();
36561     } catch (std::out_of_range& e) {
36562       {
36563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36564       };
36565     } catch (std::exception& e) {
36566       {
36567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36568       };
36569     } catch (Dali::DaliException e) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36572       };
36573     } catch (...) {
36574       {
36575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36576       };
36577     }
36578   }
36579
36580   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36581   return jresult;
36582 }
36583
36584
36585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36587   Dali::Vector2 *arg2 = 0 ;
36588
36589   arg1 = (Dali::Actor *)jarg1;
36590   arg2 = (Dali::Vector2 *)jarg2;
36591   if (!arg2) {
36592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36593     return ;
36594   }
36595   {
36596     try {
36597       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36598     } catch (std::out_of_range& e) {
36599       {
36600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36601       };
36602     } catch (std::exception& e) {
36603       {
36604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36605       };
36606     } catch (Dali::DaliException e) {
36607       {
36608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36609       };
36610     } catch (...) {
36611       {
36612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36613       };
36614     }
36615   }
36616
36617 }
36618
36619
36620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36621   void * jresult ;
36622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36623   Dali::Vector2 result;
36624
36625   arg1 = (Dali::Actor *)jarg1;
36626   {
36627     try {
36628       result = (arg1)->GetMaximumSize();
36629     } catch (std::out_of_range& e) {
36630       {
36631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36632       };
36633     } catch (std::exception& e) {
36634       {
36635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36636       };
36637     } catch (Dali::DaliException e) {
36638       {
36639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36640       };
36641     } catch (...) {
36642       {
36643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36644       };
36645     }
36646   }
36647
36648   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36649   return jresult;
36650 }
36651
36652
36653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36654   int jresult ;
36655   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36656   int result;
36657
36658   arg1 = (Dali::Actor *)jarg1;
36659   {
36660     try {
36661       result = (int)(arg1)->GetHierarchyDepth();
36662       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36663       if(parent)
36664       {
36665         const std::string parentName = parent.GetName();
36666         if(parentName.compare("rootAbsoluteLayout") == 0)
36667         {
36668           result -= 1;
36669         }
36670       }
36671     } catch (std::out_of_range& e) {
36672       {
36673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36674       };
36675     } catch (std::exception& e) {
36676       {
36677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36678       };
36679     } catch (Dali::DaliException e) {
36680       {
36681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36682       };
36683     } catch (...) {
36684       {
36685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36686       };
36687     }
36688   }
36689
36690   jresult = result;
36691   return jresult;
36692 }
36693
36694
36695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36696   unsigned int jresult ;
36697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36698   Dali::Renderer *arg2 = 0 ;
36699   unsigned int result;
36700
36701   arg1 = (Dali::Actor *)jarg1;
36702   arg2 = (Dali::Renderer *)jarg2;
36703   if (!arg2) {
36704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36705     return 0;
36706   }
36707   {
36708     try {
36709       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36710     } catch (std::out_of_range& e) {
36711       {
36712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36713       };
36714     } catch (std::exception& e) {
36715       {
36716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36717       };
36718     } catch (Dali::DaliException e) {
36719       {
36720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36721       };
36722     } catch (...) {
36723       {
36724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36725       };
36726     }
36727   }
36728
36729   jresult = result;
36730   return jresult;
36731 }
36732
36733
36734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36735   unsigned int jresult ;
36736   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36737   unsigned int result;
36738
36739   arg1 = (Dali::Actor *)jarg1;
36740   {
36741     try {
36742       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36743     } catch (std::out_of_range& e) {
36744       {
36745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36746       };
36747     } catch (std::exception& e) {
36748       {
36749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36750       };
36751     } catch (Dali::DaliException e) {
36752       {
36753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36754       };
36755     } catch (...) {
36756       {
36757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36758       };
36759     }
36760   }
36761
36762   jresult = result;
36763   return jresult;
36764 }
36765
36766
36767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36768   void * jresult ;
36769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36770   unsigned int arg2 ;
36771   Dali::Renderer result;
36772
36773   arg1 = (Dali::Actor *)jarg1;
36774   arg2 = (unsigned int)jarg2;
36775   {
36776     try {
36777       result = (arg1)->GetRendererAt(arg2);
36778     } catch (std::out_of_range& e) {
36779       {
36780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36781       };
36782     } catch (std::exception& e) {
36783       {
36784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36785       };
36786     } catch (Dali::DaliException e) {
36787       {
36788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36789       };
36790     } catch (...) {
36791       {
36792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36793       };
36794     }
36795   }
36796
36797   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36798   return jresult;
36799 }
36800
36801
36802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36804   Dali::Renderer *arg2 = 0 ;
36805
36806   arg1 = (Dali::Actor *)jarg1;
36807   arg2 = (Dali::Renderer *)jarg2;
36808   if (!arg2) {
36809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36810     return ;
36811   }
36812   {
36813     try {
36814       (arg1)->RemoveRenderer(*arg2);
36815     } catch (std::out_of_range& e) {
36816       {
36817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36818       };
36819     } catch (std::exception& e) {
36820       {
36821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36822       };
36823     } catch (Dali::DaliException e) {
36824       {
36825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36826       };
36827     } catch (...) {
36828       {
36829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36830       };
36831     }
36832   }
36833
36834 }
36835
36836
36837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36839   unsigned int arg2 ;
36840
36841   arg1 = (Dali::Actor *)jarg1;
36842   arg2 = (unsigned int)jarg2;
36843   {
36844     try {
36845       (arg1)->RemoveRenderer(arg2);
36846     } catch (std::out_of_range& e) {
36847       {
36848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36849       };
36850     } catch (std::exception& e) {
36851       {
36852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36853       };
36854     } catch (Dali::DaliException e) {
36855       {
36856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36857       };
36858     } catch (...) {
36859       {
36860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36861       };
36862     }
36863   }
36864
36865 }
36866
36867
36868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36869   void * jresult ;
36870   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36871   Dali::Actor::TouchSignalType *result = 0 ;
36872
36873   arg1 = (Dali::Actor *)jarg1;
36874   {
36875     try {
36876       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36877     } catch (std::out_of_range& e) {
36878       {
36879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36880       };
36881     } catch (std::exception& e) {
36882       {
36883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (Dali::DaliException e) {
36886       {
36887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36888       };
36889     } catch (...) {
36890       {
36891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36892       };
36893     }
36894   }
36895
36896   jresult = (void *)result;
36897   return jresult;
36898 }
36899
36900
36901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36902   void * jresult ;
36903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36904   Dali::Actor::TouchDataSignalType *result = 0 ;
36905
36906   arg1 = (Dali::Actor *)jarg1;
36907   {
36908     try {
36909       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36910     } catch (std::out_of_range& e) {
36911       {
36912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36913       };
36914     } catch (std::exception& e) {
36915       {
36916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36917       };
36918     } catch (Dali::DaliException e) {
36919       {
36920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36921       };
36922     } catch (...) {
36923       {
36924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36925       };
36926     }
36927   }
36928
36929   jresult = (void *)result;
36930   return jresult;
36931 }
36932
36933
36934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36935   void * jresult ;
36936   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36937   Dali::Actor::HoverSignalType *result = 0 ;
36938
36939   arg1 = (Dali::Actor *)jarg1;
36940   {
36941     try {
36942       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36943     } catch (std::out_of_range& e) {
36944       {
36945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36946       };
36947     } catch (std::exception& e) {
36948       {
36949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36950       };
36951     } catch (Dali::DaliException e) {
36952       {
36953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36954       };
36955     } catch (...) {
36956       {
36957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36958       };
36959     }
36960   }
36961
36962   jresult = (void *)result;
36963   return jresult;
36964 }
36965
36966
36967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36968   void * jresult ;
36969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36970   Dali::Actor::WheelEventSignalType *result = 0 ;
36971
36972   arg1 = (Dali::Actor *)jarg1;
36973   {
36974     try {
36975       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36976     } catch (std::out_of_range& e) {
36977       {
36978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36979       };
36980     } catch (std::exception& e) {
36981       {
36982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36983       };
36984     } catch (Dali::DaliException e) {
36985       {
36986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36987       };
36988     } catch (...) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36991       };
36992     }
36993   }
36994
36995   jresult = (void *)result;
36996   return jresult;
36997 }
36998
36999
37000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37001   void * jresult ;
37002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37003   Dali::Actor::OnStageSignalType *result = 0 ;
37004
37005   arg1 = (Dali::Actor *)jarg1;
37006   {
37007     try {
37008       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37009     } catch (std::out_of_range& e) {
37010       {
37011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37012       };
37013     } catch (std::exception& e) {
37014       {
37015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37016       };
37017     } catch (Dali::DaliException e) {
37018       {
37019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37020       };
37021     } catch (...) {
37022       {
37023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37024       };
37025     }
37026   }
37027
37028   jresult = (void *)result;
37029   return jresult;
37030 }
37031
37032
37033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37034   void * jresult ;
37035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37036   Dali::Actor::OffStageSignalType *result = 0 ;
37037
37038   arg1 = (Dali::Actor *)jarg1;
37039   {
37040     try {
37041       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37042     } catch (std::out_of_range& e) {
37043       {
37044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37045       };
37046     } catch (std::exception& e) {
37047       {
37048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37049       };
37050     } catch (Dali::DaliException e) {
37051       {
37052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37053       };
37054     } catch (...) {
37055       {
37056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37057       };
37058     }
37059   }
37060
37061   jresult = (void *)result;
37062   return jresult;
37063 }
37064
37065
37066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37067   void * jresult ;
37068   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37069   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37070
37071   arg1 = (Dali::Actor *)jarg1;
37072   {
37073     try {
37074       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37075     } catch (std::out_of_range& e) {
37076       {
37077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37078       };
37079     } catch (std::exception& e) {
37080       {
37081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37082       };
37083     } catch (Dali::DaliException e) {
37084       {
37085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37086       };
37087     } catch (...) {
37088       {
37089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37090       };
37091     }
37092   }
37093
37094   jresult = (void *)result;
37095   return jresult;
37096 }
37097
37098
37099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37100   Dali::Actor *arg1 = 0 ;
37101
37102   arg1 = (Dali::Actor *)jarg1;
37103   if (!arg1) {
37104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37105     return ;
37106   }
37107   {
37108     try {
37109       Dali::UnparentAndReset(*arg1);
37110     } catch (std::out_of_range& e) {
37111       {
37112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37113       };
37114     } catch (std::exception& e) {
37115       {
37116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37117       };
37118     } catch (Dali::DaliException e) {
37119       {
37120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37121       };
37122     } catch (...) {
37123       {
37124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37125       };
37126     }
37127   }
37128
37129 }
37130
37131
37132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37133   int jresult ;
37134   int result;
37135
37136   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37137   jresult = (int)result;
37138   return jresult;
37139 }
37140
37141
37142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37143   int jresult ;
37144   int result;
37145
37146   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37147   jresult = (int)result;
37148   return jresult;
37149 }
37150
37151
37152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37153   int jresult ;
37154   int result;
37155
37156   result = (int)Dali::Layer::Property::BEHAVIOR;
37157   jresult = (int)result;
37158   return jresult;
37159 }
37160
37161
37162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37163   void * jresult ;
37164   Dali::Layer::Property *result = 0 ;
37165
37166   {
37167     try {
37168       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37169     } catch (std::out_of_range& e) {
37170       {
37171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37172       };
37173     } catch (std::exception& e) {
37174       {
37175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37176       };
37177     } catch (Dali::DaliException e) {
37178       {
37179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37180       };
37181     } catch (...) {
37182       {
37183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37184       };
37185     }
37186   }
37187
37188   jresult = (void *)result;
37189   return jresult;
37190 }
37191
37192
37193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37194   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37195
37196   arg1 = (Dali::Layer::Property *)jarg1;
37197   {
37198     try {
37199       delete arg1;
37200     } catch (std::out_of_range& e) {
37201       {
37202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37203       };
37204     } catch (std::exception& e) {
37205       {
37206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37207       };
37208     } catch (Dali::DaliException e) {
37209       {
37210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37211       };
37212     } catch (...) {
37213       {
37214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37215       };
37216     }
37217   }
37218
37219 }
37220
37221
37222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37223   void * jresult ;
37224   Dali::Layer *result = 0 ;
37225
37226   {
37227     try {
37228       result = (Dali::Layer *)new Dali::Layer();
37229     } catch (std::out_of_range& e) {
37230       {
37231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37232       };
37233     } catch (std::exception& e) {
37234       {
37235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37236       };
37237     } catch (Dali::DaliException e) {
37238       {
37239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37240       };
37241     } catch (...) {
37242       {
37243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37244       };
37245     }
37246   }
37247
37248   jresult = (void *)result;
37249   return jresult;
37250 }
37251
37252
37253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37254   void * jresult ;
37255   Dali::Layer result;
37256
37257   {
37258     try {
37259       result = Dali::Layer::New();
37260     } catch (std::out_of_range& e) {
37261       {
37262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37263       };
37264     } catch (std::exception& e) {
37265       {
37266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37267       };
37268     } catch (Dali::DaliException e) {
37269       {
37270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37271       };
37272     } catch (...) {
37273       {
37274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37275       };
37276     }
37277   }
37278
37279   jresult = new Dali::Layer((const Dali::Layer &)result);
37280   return jresult;
37281 }
37282
37283
37284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37285   void * jresult ;
37286   Dali::BaseHandle arg1 ;
37287   Dali::BaseHandle *argp1 ;
37288   Dali::Layer result;
37289
37290   argp1 = (Dali::BaseHandle *)jarg1;
37291   if (!argp1) {
37292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37293     return 0;
37294   }
37295   arg1 = *argp1;
37296   {
37297     try {
37298       result = Dali::Layer::DownCast(arg1);
37299     } catch (std::out_of_range& e) {
37300       {
37301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37302       };
37303     } catch (std::exception& e) {
37304       {
37305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37306       };
37307     } catch (Dali::DaliException e) {
37308       {
37309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37310       };
37311     } catch (...) {
37312       {
37313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37314       };
37315     }
37316   }
37317
37318   jresult = new Dali::Layer((const Dali::Layer &)result);
37319   return jresult;
37320 }
37321
37322
37323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37324   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37325
37326   arg1 = (Dali::Layer *)jarg1;
37327   {
37328     try {
37329       delete arg1;
37330     } catch (std::out_of_range& e) {
37331       {
37332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37333       };
37334     } catch (std::exception& e) {
37335       {
37336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37337       };
37338     } catch (Dali::DaliException e) {
37339       {
37340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37341       };
37342     } catch (...) {
37343       {
37344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37345       };
37346     }
37347   }
37348
37349 }
37350
37351
37352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37353   void * jresult ;
37354   Dali::Layer *arg1 = 0 ;
37355   Dali::Layer *result = 0 ;
37356
37357   arg1 = (Dali::Layer *)jarg1;
37358   if (!arg1) {
37359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37360     return 0;
37361   }
37362   {
37363     try {
37364       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37365     } catch (std::out_of_range& e) {
37366       {
37367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37368       };
37369     } catch (std::exception& e) {
37370       {
37371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37372       };
37373     } catch (Dali::DaliException e) {
37374       {
37375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37376       };
37377     } catch (...) {
37378       {
37379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37380       };
37381     }
37382   }
37383
37384   jresult = (void *)result;
37385   return jresult;
37386 }
37387
37388
37389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37390   void * jresult ;
37391   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37392   Dali::Layer *arg2 = 0 ;
37393   Dali::Layer *result = 0 ;
37394
37395   arg1 = (Dali::Layer *)jarg1;
37396   arg2 = (Dali::Layer *)jarg2;
37397   if (!arg2) {
37398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37399     return 0;
37400   }
37401   {
37402     try {
37403       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37404     } catch (std::out_of_range& e) {
37405       {
37406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37407       };
37408     } catch (std::exception& e) {
37409       {
37410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37411       };
37412     } catch (Dali::DaliException e) {
37413       {
37414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37415       };
37416     } catch (...) {
37417       {
37418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37419       };
37420     }
37421   }
37422
37423   jresult = (void *)result;
37424   return jresult;
37425 }
37426
37427
37428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37429   unsigned int jresult ;
37430   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37431   unsigned int result;
37432
37433   arg1 = (Dali::Layer *)jarg1;
37434   {
37435     try {
37436       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37437     } catch (std::out_of_range& e) {
37438       {
37439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37440       };
37441     } catch (std::exception& e) {
37442       {
37443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37444       };
37445     } catch (Dali::DaliException e) {
37446       {
37447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37448       };
37449     } catch (...) {
37450       {
37451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37452       };
37453     }
37454   }
37455
37456   jresult = result;
37457   return jresult;
37458 }
37459
37460
37461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37462   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37463
37464   arg1 = (Dali::Layer *)jarg1;
37465   {
37466     try {
37467       (arg1)->Raise();
37468     } catch (std::out_of_range& e) {
37469       {
37470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37471       };
37472     } catch (std::exception& e) {
37473       {
37474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37475       };
37476     } catch (Dali::DaliException e) {
37477       {
37478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37479       };
37480     } catch (...) {
37481       {
37482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37483       };
37484     }
37485   }
37486
37487 }
37488
37489
37490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37491   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37492
37493   arg1 = (Dali::Layer *)jarg1;
37494   {
37495     try {
37496       (arg1)->Lower();
37497     } catch (std::out_of_range& e) {
37498       {
37499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37500       };
37501     } catch (std::exception& e) {
37502       {
37503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37504       };
37505     } catch (Dali::DaliException e) {
37506       {
37507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37508       };
37509     } catch (...) {
37510       {
37511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37512       };
37513     }
37514   }
37515
37516 }
37517
37518
37519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37520   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37521   Dali::Layer arg2 ;
37522   Dali::Layer *argp2 ;
37523
37524   arg1 = (Dali::Layer *)jarg1;
37525   argp2 = (Dali::Layer *)jarg2;
37526   if (!argp2) {
37527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37528     return ;
37529   }
37530   arg2 = *argp2;
37531   {
37532     try {
37533       (arg1)->RaiseAbove(arg2);
37534     } catch (std::out_of_range& e) {
37535       {
37536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37537       };
37538     } catch (std::exception& e) {
37539       {
37540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37541       };
37542     } catch (Dali::DaliException e) {
37543       {
37544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37545       };
37546     } catch (...) {
37547       {
37548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37549       };
37550     }
37551   }
37552
37553 }
37554
37555
37556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37557   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37558   Dali::Layer arg2 ;
37559   Dali::Layer *argp2 ;
37560
37561   arg1 = (Dali::Layer *)jarg1;
37562   argp2 = (Dali::Layer *)jarg2;
37563   if (!argp2) {
37564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37565     return ;
37566   }
37567   arg2 = *argp2;
37568   {
37569     try {
37570       (arg1)->LowerBelow(arg2);
37571     } catch (std::out_of_range& e) {
37572       {
37573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37574       };
37575     } catch (std::exception& e) {
37576       {
37577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37578       };
37579     } catch (Dali::DaliException e) {
37580       {
37581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37582       };
37583     } catch (...) {
37584       {
37585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37586       };
37587     }
37588   }
37589
37590 }
37591
37592
37593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37594   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37595
37596   arg1 = (Dali::Layer *)jarg1;
37597   {
37598     try {
37599       (arg1)->RaiseToTop();
37600     } catch (std::out_of_range& e) {
37601       {
37602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37603       };
37604     } catch (std::exception& e) {
37605       {
37606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37607       };
37608     } catch (Dali::DaliException e) {
37609       {
37610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37611       };
37612     } catch (...) {
37613       {
37614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37615       };
37616     }
37617   }
37618
37619 }
37620
37621
37622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37623   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37624
37625   arg1 = (Dali::Layer *)jarg1;
37626   {
37627     try {
37628       (arg1)->LowerToBottom();
37629     } catch (std::out_of_range& e) {
37630       {
37631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37632       };
37633     } catch (std::exception& e) {
37634       {
37635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37636       };
37637     } catch (Dali::DaliException e) {
37638       {
37639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37640       };
37641     } catch (...) {
37642       {
37643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37644       };
37645     }
37646   }
37647
37648 }
37649
37650
37651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37652   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37653   Dali::Layer arg2 ;
37654   Dali::Layer *argp2 ;
37655
37656   arg1 = (Dali::Layer *)jarg1;
37657   argp2 = (Dali::Layer *)jarg2;
37658   if (!argp2) {
37659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37660     return ;
37661   }
37662   arg2 = *argp2;
37663   {
37664     try {
37665       (arg1)->MoveAbove(arg2);
37666     } catch (std::out_of_range& e) {
37667       {
37668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37669       };
37670     } catch (std::exception& e) {
37671       {
37672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37673       };
37674     } catch (Dali::DaliException e) {
37675       {
37676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37677       };
37678     } catch (...) {
37679       {
37680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37681       };
37682     }
37683   }
37684
37685 }
37686
37687
37688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37689   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37690   Dali::Layer arg2 ;
37691   Dali::Layer *argp2 ;
37692
37693   arg1 = (Dali::Layer *)jarg1;
37694   argp2 = (Dali::Layer *)jarg2;
37695   if (!argp2) {
37696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37697     return ;
37698   }
37699   arg2 = *argp2;
37700   {
37701     try {
37702       (arg1)->MoveBelow(arg2);
37703     } catch (std::out_of_range& e) {
37704       {
37705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37706       };
37707     } catch (std::exception& e) {
37708       {
37709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37710       };
37711     } catch (Dali::DaliException e) {
37712       {
37713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37714       };
37715     } catch (...) {
37716       {
37717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37718       };
37719     }
37720   }
37721
37722 }
37723
37724
37725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37726   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37727   Dali::Layer::Behavior arg2 ;
37728
37729   arg1 = (Dali::Layer *)jarg1;
37730   arg2 = (Dali::Layer::Behavior)jarg2;
37731   {
37732     try {
37733       (arg1)->SetBehavior(arg2);
37734     } catch (std::out_of_range& e) {
37735       {
37736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37737       };
37738     } catch (std::exception& e) {
37739       {
37740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37741       };
37742     } catch (Dali::DaliException e) {
37743       {
37744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37745       };
37746     } catch (...) {
37747       {
37748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37749       };
37750     }
37751   }
37752
37753 }
37754
37755
37756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37757   int jresult ;
37758   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37759   Dali::Layer::Behavior result;
37760
37761   arg1 = (Dali::Layer *)jarg1;
37762   {
37763     try {
37764       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37765     } catch (std::out_of_range& e) {
37766       {
37767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37768       };
37769     } catch (std::exception& e) {
37770       {
37771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37772       };
37773     } catch (Dali::DaliException e) {
37774       {
37775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37776       };
37777     } catch (...) {
37778       {
37779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37780       };
37781     }
37782   }
37783
37784   jresult = (int)result;
37785   return jresult;
37786 }
37787
37788
37789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37790   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37791   bool arg2 ;
37792
37793   arg1 = (Dali::Layer *)jarg1;
37794   arg2 = jarg2 ? true : false;
37795   {
37796     try {
37797       (arg1)->SetClipping(arg2);
37798     } catch (std::out_of_range& e) {
37799       {
37800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37801       };
37802     } catch (std::exception& e) {
37803       {
37804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37805       };
37806     } catch (Dali::DaliException e) {
37807       {
37808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37809       };
37810     } catch (...) {
37811       {
37812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37813       };
37814     }
37815   }
37816
37817 }
37818
37819
37820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37821   unsigned int jresult ;
37822   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37823   bool result;
37824
37825   arg1 = (Dali::Layer *)jarg1;
37826   {
37827     try {
37828       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37829     } catch (std::out_of_range& e) {
37830       {
37831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37832       };
37833     } catch (std::exception& e) {
37834       {
37835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37836       };
37837     } catch (Dali::DaliException e) {
37838       {
37839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37840       };
37841     } catch (...) {
37842       {
37843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37844       };
37845     }
37846   }
37847
37848   jresult = result;
37849   return jresult;
37850 }
37851
37852
37853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37854   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37855   int arg2 ;
37856   int arg3 ;
37857   int arg4 ;
37858   int arg5 ;
37859
37860   arg1 = (Dali::Layer *)jarg1;
37861   arg2 = (int)jarg2;
37862   arg3 = (int)jarg3;
37863   arg4 = (int)jarg4;
37864   arg5 = (int)jarg5;
37865   {
37866     try {
37867       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37868     } catch (std::out_of_range& e) {
37869       {
37870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37871       };
37872     } catch (std::exception& e) {
37873       {
37874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37875       };
37876     } catch (Dali::DaliException e) {
37877       {
37878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37879       };
37880     } catch (...) {
37881       {
37882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37883       };
37884     }
37885   }
37886
37887 }
37888
37889
37890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37891   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37892   Dali::ClippingBox arg2 ;
37893   Dali::ClippingBox *argp2 ;
37894
37895   arg1 = (Dali::Layer *)jarg1;
37896   argp2 = (Dali::ClippingBox *)jarg2;
37897   if (!argp2) {
37898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37899     return ;
37900   }
37901   arg2 = *argp2;
37902   {
37903     try {
37904       (arg1)->SetClippingBox(arg2);
37905     } catch (std::out_of_range& e) {
37906       {
37907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37908       };
37909     } catch (std::exception& e) {
37910       {
37911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37912       };
37913     } catch (Dali::DaliException e) {
37914       {
37915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37916       };
37917     } catch (...) {
37918       {
37919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37920       };
37921     }
37922   }
37923
37924 }
37925
37926
37927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37928   void * jresult ;
37929   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37930   Dali::ClippingBox result;
37931
37932   arg1 = (Dali::Layer *)jarg1;
37933   {
37934     try {
37935       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37936     } catch (std::out_of_range& e) {
37937       {
37938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37939       };
37940     } catch (std::exception& e) {
37941       {
37942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37943       };
37944     } catch (Dali::DaliException e) {
37945       {
37946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37947       };
37948     } catch (...) {
37949       {
37950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37951       };
37952     }
37953   }
37954
37955   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37956   return jresult;
37957 }
37958
37959
37960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37961   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37962   bool arg2 ;
37963
37964   arg1 = (Dali::Layer *)jarg1;
37965   arg2 = jarg2 ? true : false;
37966   {
37967     try {
37968       (arg1)->SetDepthTestDisabled(arg2);
37969     } catch (std::out_of_range& e) {
37970       {
37971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37972       };
37973     } catch (std::exception& e) {
37974       {
37975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37976       };
37977     } catch (Dali::DaliException e) {
37978       {
37979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37980       };
37981     } catch (...) {
37982       {
37983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37984       };
37985     }
37986   }
37987
37988 }
37989
37990
37991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37992   unsigned int jresult ;
37993   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37994   bool result;
37995
37996   arg1 = (Dali::Layer *)jarg1;
37997   {
37998     try {
37999       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38000     } catch (std::out_of_range& e) {
38001       {
38002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38003       };
38004     } catch (std::exception& e) {
38005       {
38006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38007       };
38008     } catch (Dali::DaliException e) {
38009       {
38010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38011       };
38012     } catch (...) {
38013       {
38014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38015       };
38016     }
38017   }
38018
38019   jresult = result;
38020   return jresult;
38021 }
38022
38023
38024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38025   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38026   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38027
38028   arg1 = (Dali::Layer *)jarg1;
38029   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38030   {
38031     try {
38032       (arg1)->SetSortFunction(arg2);
38033     } catch (std::out_of_range& e) {
38034       {
38035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38036       };
38037     } catch (std::exception& e) {
38038       {
38039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38040       };
38041     } catch (Dali::DaliException e) {
38042       {
38043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38044       };
38045     } catch (...) {
38046       {
38047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38048       };
38049     }
38050   }
38051
38052 }
38053
38054
38055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38056   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38057   bool arg2 ;
38058
38059   arg1 = (Dali::Layer *)jarg1;
38060   arg2 = jarg2 ? true : false;
38061   {
38062     try {
38063       (arg1)->SetTouchConsumed(arg2);
38064     } catch (std::out_of_range& e) {
38065       {
38066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38067       };
38068     } catch (std::exception& e) {
38069       {
38070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38071       };
38072     } catch (Dali::DaliException e) {
38073       {
38074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38075       };
38076     } catch (...) {
38077       {
38078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38079       };
38080     }
38081   }
38082
38083 }
38084
38085
38086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38087   unsigned int jresult ;
38088   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38089   bool result;
38090
38091   arg1 = (Dali::Layer *)jarg1;
38092   {
38093     try {
38094       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38095     } catch (std::out_of_range& e) {
38096       {
38097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38098       };
38099     } catch (std::exception& e) {
38100       {
38101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38102       };
38103     } catch (Dali::DaliException e) {
38104       {
38105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38106       };
38107     } catch (...) {
38108       {
38109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38110       };
38111     }
38112   }
38113
38114   jresult = result;
38115   return jresult;
38116 }
38117
38118
38119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38120   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38121   bool arg2 ;
38122
38123   arg1 = (Dali::Layer *)jarg1;
38124   arg2 = jarg2 ? true : false;
38125   {
38126     try {
38127       (arg1)->SetHoverConsumed(arg2);
38128     } catch (std::out_of_range& e) {
38129       {
38130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38131       };
38132     } catch (std::exception& e) {
38133       {
38134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38135       };
38136     } catch (Dali::DaliException e) {
38137       {
38138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38139       };
38140     } catch (...) {
38141       {
38142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38143       };
38144     }
38145   }
38146
38147 }
38148
38149
38150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38151   unsigned int jresult ;
38152   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38153   bool result;
38154
38155   arg1 = (Dali::Layer *)jarg1;
38156   {
38157     try {
38158       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38159     } catch (std::out_of_range& e) {
38160       {
38161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38162       };
38163     } catch (std::exception& e) {
38164       {
38165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38166       };
38167     } catch (Dali::DaliException e) {
38168       {
38169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38170       };
38171     } catch (...) {
38172       {
38173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38174       };
38175     }
38176   }
38177
38178   jresult = result;
38179   return jresult;
38180 }
38181
38182
38183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38184   void * jresult ;
38185   Dali::Vector4 *result = 0 ;
38186
38187   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38188   jresult = (void *)result;
38189   return jresult;
38190 }
38191
38192
38193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38194   void * jresult ;
38195   Dali::Vector4 *result = 0 ;
38196
38197   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38198   jresult = (void *)result;
38199   return jresult;
38200 }
38201
38202
38203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38204   void * jresult ;
38205   Dali::Stage *result = 0 ;
38206
38207   {
38208     try {
38209       result = (Dali::Stage *)new Dali::Stage();
38210     } catch (std::out_of_range& e) {
38211       {
38212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38213       };
38214     } catch (std::exception& e) {
38215       {
38216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38217       };
38218     } catch (Dali::DaliException e) {
38219       {
38220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38221       };
38222     } catch (...) {
38223       {
38224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38225       };
38226     }
38227   }
38228
38229   jresult = (void *)result;
38230   return jresult;
38231 }
38232
38233
38234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38235   void * jresult ;
38236   Dali::Stage result;
38237
38238   {
38239     try {
38240       result = Dali::Stage::GetCurrent();
38241     } catch (std::out_of_range& e) {
38242       {
38243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38244       };
38245     } catch (std::exception& e) {
38246       {
38247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38248       };
38249     } catch (Dali::DaliException e) {
38250       {
38251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38252       };
38253     } catch (...) {
38254       {
38255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38256       };
38257     }
38258   }
38259
38260   jresult = new Dali::Stage((const Dali::Stage &)result);
38261   return jresult;
38262 }
38263
38264
38265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38266   unsigned int jresult ;
38267   bool result;
38268
38269   {
38270     try {
38271       result = (bool)Dali::Stage::IsInstalled();
38272     } catch (std::out_of_range& e) {
38273       {
38274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38275       };
38276     } catch (std::exception& e) {
38277       {
38278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38279       };
38280     } catch (Dali::DaliException e) {
38281       {
38282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38283       };
38284     } catch (...) {
38285       {
38286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38287       };
38288     }
38289   }
38290
38291   jresult = result;
38292   return jresult;
38293 }
38294
38295
38296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38297   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38298
38299   arg1 = (Dali::Stage *)jarg1;
38300   {
38301     try {
38302       delete arg1;
38303     } catch (std::out_of_range& e) {
38304       {
38305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38306       };
38307     } catch (std::exception& e) {
38308       {
38309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38310       };
38311     } catch (Dali::DaliException e) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38314       };
38315     } catch (...) {
38316       {
38317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38318       };
38319     }
38320   }
38321
38322 }
38323
38324
38325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38326   void * jresult ;
38327   Dali::Stage *arg1 = 0 ;
38328   Dali::Stage *result = 0 ;
38329
38330   arg1 = (Dali::Stage *)jarg1;
38331   if (!arg1) {
38332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38333     return 0;
38334   }
38335   {
38336     try {
38337       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38338     } catch (std::out_of_range& e) {
38339       {
38340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38341       };
38342     } catch (std::exception& e) {
38343       {
38344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38345       };
38346     } catch (Dali::DaliException e) {
38347       {
38348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38349       };
38350     } catch (...) {
38351       {
38352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38353       };
38354     }
38355   }
38356
38357   jresult = (void *)result;
38358   return jresult;
38359 }
38360
38361
38362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38363   void * jresult ;
38364   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38365   Dali::Stage *arg2 = 0 ;
38366   Dali::Stage *result = 0 ;
38367
38368   arg1 = (Dali::Stage *)jarg1;
38369   arg2 = (Dali::Stage *)jarg2;
38370   if (!arg2) {
38371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38372     return 0;
38373   }
38374   {
38375     try {
38376       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38377     } catch (std::out_of_range& e) {
38378       {
38379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38380       };
38381     } catch (std::exception& e) {
38382       {
38383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38384       };
38385     } catch (Dali::DaliException e) {
38386       {
38387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38388       };
38389     } catch (...) {
38390       {
38391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38392       };
38393     }
38394   }
38395
38396   jresult = (void *)result;
38397   return jresult;
38398 }
38399
38400
38401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38402   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38403   Dali::Actor *arg2 = 0 ;
38404
38405   arg1 = (Dali::Stage *)jarg1;
38406   arg2 = (Dali::Actor *)jarg2;
38407   if (!arg2) {
38408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38409     return ;
38410   }
38411   {
38412     try {
38413       (arg1)->Add(*arg2);
38414     } catch (std::out_of_range& e) {
38415       {
38416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38417       };
38418     } catch (std::exception& e) {
38419       {
38420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38421       };
38422     } catch (Dali::DaliException e) {
38423       {
38424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38425       };
38426     } catch (...) {
38427       {
38428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38429       };
38430     }
38431   }
38432
38433 }
38434
38435
38436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38437   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38438   Dali::Actor *arg2 = 0 ;
38439
38440   arg1 = (Dali::Stage *)jarg1;
38441   arg2 = (Dali::Actor *)jarg2;
38442   if (!arg2) {
38443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38444     return ;
38445   }
38446   {
38447     try {
38448       (arg1)->Remove(*arg2);
38449     } catch (std::out_of_range& e) {
38450       {
38451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38452       };
38453     } catch (std::exception& e) {
38454       {
38455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38456       };
38457     } catch (Dali::DaliException e) {
38458       {
38459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38460       };
38461     } catch (...) {
38462       {
38463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38464       };
38465     }
38466   }
38467
38468 }
38469
38470
38471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38472   void * jresult ;
38473   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38474   Dali::Vector2 result;
38475
38476   arg1 = (Dali::Stage *)jarg1;
38477   {
38478     try {
38479       result = ((Dali::Stage const *)arg1)->GetSize();
38480     } catch (std::out_of_range& e) {
38481       {
38482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38483       };
38484     } catch (std::exception& e) {
38485       {
38486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38487       };
38488     } catch (Dali::DaliException e) {
38489       {
38490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38491       };
38492     } catch (...) {
38493       {
38494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38495       };
38496     }
38497   }
38498
38499   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38500   return jresult;
38501 }
38502
38503
38504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38505   void * jresult ;
38506   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38507   Dali::RenderTaskList result;
38508
38509   arg1 = (Dali::Stage *)jarg1;
38510   {
38511     try {
38512       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38513     } catch (std::out_of_range& e) {
38514       {
38515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38516       };
38517     } catch (std::exception& e) {
38518       {
38519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38520       };
38521     } catch (Dali::DaliException e) {
38522       {
38523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38524       };
38525     } catch (...) {
38526       {
38527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38528       };
38529     }
38530   }
38531
38532   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38533   return jresult;
38534 }
38535
38536
38537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38538   unsigned int jresult ;
38539   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38540   unsigned int result;
38541
38542   arg1 = (Dali::Stage *)jarg1;
38543   {
38544     try {
38545       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38546     } catch (std::out_of_range& e) {
38547       {
38548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38549       };
38550     } catch (std::exception& e) {
38551       {
38552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38553       };
38554     } catch (Dali::DaliException e) {
38555       {
38556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38557       };
38558     } catch (...) {
38559       {
38560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38561       };
38562     }
38563   }
38564
38565   jresult = result;
38566   return jresult;
38567 }
38568
38569
38570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38571   void * jresult ;
38572   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38573   unsigned int arg2 ;
38574   Dali::Layer result;
38575
38576   arg1 = (Dali::Stage *)jarg1;
38577   arg2 = (unsigned int)jarg2;
38578   {
38579     try {
38580       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38581     } catch (std::out_of_range& e) {
38582       {
38583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38584       };
38585     } catch (std::exception& e) {
38586       {
38587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38588       };
38589     } catch (Dali::DaliException e) {
38590       {
38591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38592       };
38593     } catch (...) {
38594       {
38595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38596       };
38597     }
38598   }
38599
38600   jresult = new Dali::Layer((const Dali::Layer &)result);
38601   return jresult;
38602 }
38603
38604
38605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38606   void * jresult ;
38607   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38608   Dali::Layer result;
38609
38610   arg1 = (Dali::Stage *)jarg1;
38611   {
38612     try {
38613       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38614     } catch (std::out_of_range& e) {
38615       {
38616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38617       };
38618     } catch (std::exception& e) {
38619       {
38620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38621       };
38622     } catch (Dali::DaliException e) {
38623       {
38624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38625       };
38626     } catch (...) {
38627       {
38628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38629       };
38630     }
38631   }
38632
38633   jresult = new Dali::Layer((const Dali::Layer &)result);
38634   return jresult;
38635 }
38636
38637
38638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38639   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38640   Dali::Vector4 arg2 ;
38641   Dali::Vector4 *argp2 ;
38642
38643   arg1 = (Dali::Stage *)jarg1;
38644   argp2 = (Dali::Vector4 *)jarg2;
38645   if (!argp2) {
38646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38647     return ;
38648   }
38649   arg2 = *argp2;
38650   {
38651     try {
38652       (arg1)->SetBackgroundColor(arg2);
38653     } catch (std::out_of_range& e) {
38654       {
38655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38656       };
38657     } catch (std::exception& e) {
38658       {
38659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38660       };
38661     } catch (Dali::DaliException e) {
38662       {
38663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38664       };
38665     } catch (...) {
38666       {
38667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38668       };
38669     }
38670   }
38671
38672 }
38673
38674
38675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38676   void * jresult ;
38677   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38678   Dali::Vector4 result;
38679
38680   arg1 = (Dali::Stage *)jarg1;
38681   {
38682     try {
38683       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38684     } catch (std::out_of_range& e) {
38685       {
38686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38687       };
38688     } catch (std::exception& e) {
38689       {
38690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38691       };
38692     } catch (Dali::DaliException e) {
38693       {
38694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38695       };
38696     } catch (...) {
38697       {
38698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38699       };
38700     }
38701   }
38702
38703   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38704   return jresult;
38705 }
38706
38707
38708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38709   void * jresult ;
38710   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38711   Dali::Vector2 result;
38712
38713   arg1 = (Dali::Stage *)jarg1;
38714   {
38715     try {
38716       result = ((Dali::Stage const *)arg1)->GetDpi();
38717     } catch (std::out_of_range& e) {
38718       {
38719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38720       };
38721     } catch (std::exception& e) {
38722       {
38723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38724       };
38725     } catch (Dali::DaliException e) {
38726       {
38727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38728       };
38729     } catch (...) {
38730       {
38731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38732       };
38733     }
38734   }
38735
38736   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38737   return jresult;
38738 }
38739
38740
38741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38742   void * jresult ;
38743   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38744   Dali::ObjectRegistry result;
38745
38746   arg1 = (Dali::Stage *)jarg1;
38747   {
38748     try {
38749       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38750     } catch (std::out_of_range& e) {
38751       {
38752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38753       };
38754     } catch (std::exception& e) {
38755       {
38756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38757       };
38758     } catch (Dali::DaliException e) {
38759       {
38760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38761       };
38762     } catch (...) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38765       };
38766     }
38767   }
38768
38769   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38770   return jresult;
38771 }
38772
38773
38774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38775   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38776   float arg2 ;
38777
38778   arg1 = (Dali::Stage *)jarg1;
38779   arg2 = (float)jarg2;
38780   {
38781     try {
38782       (arg1)->KeepRendering(arg2);
38783     } catch (std::out_of_range& e) {
38784       {
38785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38786       };
38787     } catch (std::exception& e) {
38788       {
38789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38790       };
38791     } catch (Dali::DaliException e) {
38792       {
38793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38794       };
38795     } catch (...) {
38796       {
38797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38798       };
38799     }
38800   }
38801
38802 }
38803
38804
38805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38806   void * jresult ;
38807   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38808   Dali::Stage::KeyEventSignalType *result = 0 ;
38809
38810   arg1 = (Dali::Stage *)jarg1;
38811   {
38812     try {
38813       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38814     } catch (std::out_of_range& e) {
38815       {
38816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38817       };
38818     } catch (std::exception& e) {
38819       {
38820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38821       };
38822     } catch (Dali::DaliException e) {
38823       {
38824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38825       };
38826     } catch (...) {
38827       {
38828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38829       };
38830     }
38831   }
38832
38833   jresult = (void *)result;
38834   return jresult;
38835 }
38836
38837
38838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38839   void * jresult ;
38840   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38841   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38842
38843   arg1 = (Dali::Stage *)jarg1;
38844   {
38845     try {
38846       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38847     } catch (std::out_of_range& e) {
38848       {
38849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38850       };
38851     } catch (std::exception& e) {
38852       {
38853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38854       };
38855     } catch (Dali::DaliException e) {
38856       {
38857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38858       };
38859     } catch (...) {
38860       {
38861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38862       };
38863     }
38864   }
38865
38866   jresult = (void *)result;
38867   return jresult;
38868 }
38869
38870
38871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38872   void * jresult ;
38873   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38874   Dali::Stage::TouchSignalType *result = 0 ;
38875
38876   arg1 = (Dali::Stage *)jarg1;
38877   {
38878     try {
38879       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38880     } catch (std::out_of_range& e) {
38881       {
38882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38883       };
38884     } catch (std::exception& e) {
38885       {
38886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38887       };
38888     } catch (Dali::DaliException e) {
38889       {
38890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38891       };
38892     } catch (...) {
38893       {
38894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38895       };
38896     }
38897   }
38898
38899   jresult = (void *)result;
38900   return jresult;
38901 }
38902
38903
38904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38905   void * jresult ;
38906   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38907   Dali::Stage::WheelEventSignalType *result = 0 ;
38908
38909   arg1 = (Dali::Stage *)jarg1;
38910   {
38911     try {
38912       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38913     } catch (std::out_of_range& e) {
38914       {
38915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38916       };
38917     } catch (std::exception& e) {
38918       {
38919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38920       };
38921     } catch (Dali::DaliException e) {
38922       {
38923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38924       };
38925     } catch (...) {
38926       {
38927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38928       };
38929     }
38930   }
38931
38932   jresult = (void *)result;
38933   return jresult;
38934 }
38935
38936
38937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38938   void * jresult ;
38939   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38940   Dali::Stage::ContextStatusSignal *result = 0 ;
38941
38942   arg1 = (Dali::Stage *)jarg1;
38943   {
38944     try {
38945       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38946     } catch (std::out_of_range& e) {
38947       {
38948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38949       };
38950     } catch (std::exception& e) {
38951       {
38952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38953       };
38954     } catch (Dali::DaliException e) {
38955       {
38956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38957       };
38958     } catch (...) {
38959       {
38960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38961       };
38962     }
38963   }
38964
38965   jresult = (void *)result;
38966   return jresult;
38967 }
38968
38969
38970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38971   void * jresult ;
38972   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38973   Dali::Stage::ContextStatusSignal *result = 0 ;
38974
38975   arg1 = (Dali::Stage *)jarg1;
38976   {
38977     try {
38978       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38979     } catch (std::out_of_range& e) {
38980       {
38981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38982       };
38983     } catch (std::exception& e) {
38984       {
38985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38986       };
38987     } catch (Dali::DaliException e) {
38988       {
38989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38990       };
38991     } catch (...) {
38992       {
38993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38994       };
38995     }
38996   }
38997
38998   jresult = (void *)result;
38999   return jresult;
39000 }
39001
39002
39003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39004   void * jresult ;
39005   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39006   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39007
39008   arg1 = (Dali::Stage *)jarg1;
39009   {
39010     try {
39011       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39012     } catch (std::out_of_range& e) {
39013       {
39014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39015       };
39016     } catch (std::exception& e) {
39017       {
39018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39019       };
39020     } catch (Dali::DaliException e) {
39021       {
39022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39023       };
39024     } catch (...) {
39025       {
39026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39027       };
39028     }
39029   }
39030
39031   jresult = (void *)result;
39032   return jresult;
39033 }
39034
39035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39036   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39037   Dali::DevelStage::Rendering arg2 ;
39038
39039   arg1 = (Dali::Stage *)jarg1;
39040   arg2 = (Dali::DevelStage::Rendering)jarg2;
39041   {
39042     try {
39043       DevelStage::SetRenderingBehavior(*arg1,arg2);
39044     } catch (std::out_of_range& e) {
39045       {
39046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39047       };
39048     } catch (std::exception& e) {
39049       {
39050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39051       };
39052     } catch (Dali::DaliException e) {
39053       {
39054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39055       };
39056     } catch (...) {
39057       {
39058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39059       };
39060     }
39061   }
39062
39063 }
39064
39065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39066
39067   int jresult ;
39068   int result ;
39069   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39070
39071   arg1 = (Dali::Stage *)jarg1;
39072   {
39073     try {
39074       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39075     } catch (std::out_of_range& e) {
39076       {
39077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (std::exception& e) {
39080       {
39081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39082       };
39083     } catch (Dali::DaliException e) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39090       };
39091     }
39092   }
39093
39094   jresult = result;
39095   return jresult;
39096 }
39097
39098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39099   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39100
39101   arg1 = (Dali::RelayoutContainer *)jarg1;
39102   {
39103     try {
39104       delete arg1;
39105     } catch (std::out_of_range& e) {
39106       {
39107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39108       };
39109     } catch (std::exception& e) {
39110       {
39111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39112       };
39113     } catch (Dali::DaliException e) {
39114       {
39115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39116       };
39117     } catch (...) {
39118       {
39119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39120       };
39121     }
39122   }
39123
39124 }
39125
39126
39127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39128   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39129   Dali::Actor *arg2 = 0 ;
39130   Dali::Vector2 *arg3 = 0 ;
39131
39132   arg1 = (Dali::RelayoutContainer *)jarg1;
39133   arg2 = (Dali::Actor *)jarg2;
39134   if (!arg2) {
39135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39136     return ;
39137   }
39138   arg3 = (Dali::Vector2 *)jarg3;
39139   if (!arg3) {
39140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39141     return ;
39142   }
39143   {
39144     try {
39145       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39146     } catch (std::out_of_range& e) {
39147       {
39148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39149       };
39150     } catch (std::exception& e) {
39151       {
39152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39153       };
39154     } catch (Dali::DaliException e) {
39155       {
39156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39157       };
39158     } catch (...) {
39159       {
39160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39161       };
39162     }
39163   }
39164
39165 }
39166
39167
39168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39169   void * jresult ;
39170   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39171   Dali::CustomActor result;
39172
39173   arg1 = (Dali::CustomActorImpl *)jarg1;
39174   {
39175     try {
39176       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39177     } catch (std::out_of_range& e) {
39178       {
39179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39180       };
39181     } catch (std::exception& e) {
39182       {
39183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39184       };
39185     } catch (Dali::DaliException e) {
39186       {
39187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39188       };
39189     } catch (...) {
39190       {
39191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39192       };
39193     }
39194   }
39195
39196   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39197   return jresult;
39198 }
39199
39200
39201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39202   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39203   int arg2 ;
39204
39205   arg1 = (Dali::CustomActorImpl *)jarg1;
39206   arg2 = (int)jarg2;
39207   {
39208     try {
39209       (arg1)->OnStageConnection(arg2);
39210     } catch (std::out_of_range& e) {
39211       {
39212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39213       };
39214     } catch (std::exception& e) {
39215       {
39216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39217       };
39218     } catch (Dali::DaliException e) {
39219       {
39220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39221       };
39222     } catch (...) {
39223       {
39224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39225       };
39226     }
39227   }
39228
39229 }
39230
39231
39232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39233   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39234
39235   arg1 = (Dali::CustomActorImpl *)jarg1;
39236   {
39237     try {
39238       (arg1)->OnStageDisconnection();
39239     } catch (std::out_of_range& e) {
39240       {
39241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39242       };
39243     } catch (std::exception& e) {
39244       {
39245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (Dali::DaliException e) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39250       };
39251     } catch (...) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39254       };
39255     }
39256   }
39257
39258 }
39259
39260
39261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39262   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39263   Dali::Actor *arg2 = 0 ;
39264
39265   arg1 = (Dali::CustomActorImpl *)jarg1;
39266   arg2 = (Dali::Actor *)jarg2;
39267   if (!arg2) {
39268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39269     return ;
39270   }
39271   {
39272     try {
39273       (arg1)->OnChildAdd(*arg2);
39274     } catch (std::out_of_range& e) {
39275       {
39276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39277       };
39278     } catch (std::exception& e) {
39279       {
39280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39281       };
39282     } catch (Dali::DaliException e) {
39283       {
39284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39285       };
39286     } catch (...) {
39287       {
39288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39289       };
39290     }
39291   }
39292
39293 }
39294
39295
39296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39297   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39298   Dali::Actor *arg2 = 0 ;
39299
39300   arg1 = (Dali::CustomActorImpl *)jarg1;
39301   arg2 = (Dali::Actor *)jarg2;
39302   if (!arg2) {
39303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39304     return ;
39305   }
39306   {
39307     try {
39308       (arg1)->OnChildRemove(*arg2);
39309     } catch (std::out_of_range& e) {
39310       {
39311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39312       };
39313     } catch (std::exception& e) {
39314       {
39315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39316       };
39317     } catch (Dali::DaliException e) {
39318       {
39319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39320       };
39321     } catch (...) {
39322       {
39323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39324       };
39325     }
39326   }
39327
39328 }
39329
39330
39331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39332   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39333   Dali::Property::Index arg2 ;
39334   Dali::Property::Value arg3 ;
39335   Dali::Property::Value *argp3 ;
39336
39337   arg1 = (Dali::CustomActorImpl *)jarg1;
39338   arg2 = (Dali::Property::Index)jarg2;
39339   argp3 = (Dali::Property::Value *)jarg3;
39340   if (!argp3) {
39341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39342     return ;
39343   }
39344   arg3 = *argp3;
39345   {
39346     try {
39347       (arg1)->OnPropertySet(arg2,arg3);
39348     } catch (std::out_of_range& e) {
39349       {
39350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39351       };
39352     } catch (std::exception& e) {
39353       {
39354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39355       };
39356     } catch (Dali::DaliException e) {
39357       {
39358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39359       };
39360     } catch (...) {
39361       {
39362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39363       };
39364     }
39365   }
39366
39367 }
39368
39369
39370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39371   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39372   Dali::Vector3 *arg2 = 0 ;
39373
39374   arg1 = (Dali::CustomActorImpl *)jarg1;
39375   arg2 = (Dali::Vector3 *)jarg2;
39376   if (!arg2) {
39377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39378     return ;
39379   }
39380   {
39381     try {
39382       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39383     } catch (std::out_of_range& e) {
39384       {
39385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39386       };
39387     } catch (std::exception& e) {
39388       {
39389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39390       };
39391     } catch (Dali::DaliException e) {
39392       {
39393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39394       };
39395     } catch (...) {
39396       {
39397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39398       };
39399     }
39400   }
39401
39402 }
39403
39404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39405   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39406   Dali::Animation *arg2 = 0 ;
39407   Dali::Vector3 *arg3 = 0 ;
39408
39409   arg1 = (Dali::CustomActorImpl *)jarg1;
39410   arg2 = (Dali::Animation *)jarg2;
39411   if (!arg2) {
39412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39413     return ;
39414   }
39415   arg3 = (Dali::Vector3 *)jarg3;
39416   if (!arg3) {
39417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39418     return ;
39419   }
39420   {
39421     try {
39422       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39423     } catch (std::out_of_range& e) {
39424       {
39425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39426       };
39427     } catch (std::exception& e) {
39428       {
39429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39430       };
39431     } catch (Dali::DaliException e) {
39432       {
39433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39434       };
39435     } catch (...) {
39436       {
39437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39438       };
39439     }
39440   }
39441
39442 }
39443
39444
39445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39446   unsigned int jresult ;
39447   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39448   Dali::TouchEvent *arg2 = 0 ;
39449   bool result;
39450
39451   arg1 = (Dali::CustomActorImpl *)jarg1;
39452   arg2 = (Dali::TouchEvent *)jarg2;
39453   if (!arg2) {
39454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39455     return 0;
39456   }
39457   {
39458     try {
39459       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39460     } catch (std::out_of_range& e) {
39461       {
39462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39463       };
39464     } catch (std::exception& e) {
39465       {
39466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39467       };
39468     } catch (Dali::DaliException e) {
39469       {
39470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39471       };
39472     } catch (...) {
39473       {
39474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39475       };
39476     }
39477   }
39478
39479   jresult = result;
39480   return jresult;
39481 }
39482
39483
39484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39485   unsigned int jresult ;
39486   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39487   Dali::HoverEvent *arg2 = 0 ;
39488   bool result;
39489
39490   arg1 = (Dali::CustomActorImpl *)jarg1;
39491   arg2 = (Dali::HoverEvent *)jarg2;
39492   if (!arg2) {
39493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39494     return 0;
39495   }
39496   {
39497     try {
39498       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39499     } catch (std::out_of_range& e) {
39500       {
39501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39502       };
39503     } catch (std::exception& e) {
39504       {
39505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39506       };
39507     } catch (Dali::DaliException e) {
39508       {
39509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39510       };
39511     } catch (...) {
39512       {
39513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39514       };
39515     }
39516   }
39517
39518   jresult = result;
39519   return jresult;
39520 }
39521
39522
39523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39524   unsigned int jresult ;
39525   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39526   Dali::KeyEvent *arg2 = 0 ;
39527   bool result;
39528
39529   arg1 = (Dali::CustomActorImpl *)jarg1;
39530   arg2 = (Dali::KeyEvent *)jarg2;
39531   if (!arg2) {
39532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39533     return 0;
39534   }
39535   {
39536     try {
39537       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39538     } catch (std::out_of_range& e) {
39539       {
39540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39541       };
39542     } catch (std::exception& e) {
39543       {
39544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39545       };
39546     } catch (Dali::DaliException e) {
39547       {
39548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39549       };
39550     } catch (...) {
39551       {
39552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39553       };
39554     }
39555   }
39556
39557   jresult = result;
39558   return jresult;
39559 }
39560
39561
39562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39563   unsigned int jresult ;
39564   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39565   Dali::WheelEvent *arg2 = 0 ;
39566   bool result;
39567
39568   arg1 = (Dali::CustomActorImpl *)jarg1;
39569   arg2 = (Dali::WheelEvent *)jarg2;
39570   if (!arg2) {
39571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39572     return 0;
39573   }
39574   {
39575     try {
39576       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39577     } catch (std::out_of_range& e) {
39578       {
39579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39580       };
39581     } catch (std::exception& e) {
39582       {
39583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39584       };
39585     } catch (Dali::DaliException e) {
39586       {
39587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39588       };
39589     } catch (...) {
39590       {
39591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39592       };
39593     }
39594   }
39595
39596   jresult = result;
39597   return jresult;
39598 }
39599
39600
39601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39602   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39603   Dali::Vector2 *arg2 = 0 ;
39604   Dali::RelayoutContainer *arg3 = 0 ;
39605
39606   arg1 = (Dali::CustomActorImpl *)jarg1;
39607   arg2 = (Dali::Vector2 *)jarg2;
39608   if (!arg2) {
39609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39610     return ;
39611   }
39612   arg3 = (Dali::RelayoutContainer *)jarg3;
39613   if (!arg3) {
39614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39615     return ;
39616   }
39617   {
39618     try {
39619       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39620     } catch (std::out_of_range& e) {
39621       {
39622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39623       };
39624     } catch (std::exception& e) {
39625       {
39626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39627       };
39628     } catch (Dali::DaliException e) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39631       };
39632     } catch (...) {
39633       {
39634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39635       };
39636     }
39637   }
39638
39639 }
39640
39641
39642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39644   Dali::ResizePolicy::Type arg2 ;
39645   Dali::Dimension::Type arg3 ;
39646
39647   arg1 = (Dali::CustomActorImpl *)jarg1;
39648   arg2 = (Dali::ResizePolicy::Type)jarg2;
39649   arg3 = (Dali::Dimension::Type)jarg3;
39650   {
39651     try {
39652       (arg1)->OnSetResizePolicy(arg2,arg3);
39653     } catch (std::out_of_range& e) {
39654       {
39655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39656       };
39657     } catch (std::exception& e) {
39658       {
39659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39660       };
39661     } catch (Dali::DaliException e) {
39662       {
39663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39664       };
39665     } catch (...) {
39666       {
39667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39668       };
39669     }
39670   }
39671
39672 }
39673
39674
39675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39676   void * jresult ;
39677   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39678   Dali::Vector3 result;
39679
39680   arg1 = (Dali::CustomActorImpl *)jarg1;
39681   {
39682     try {
39683       result = (arg1)->GetNaturalSize();
39684     } catch (std::out_of_range& e) {
39685       {
39686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39687       };
39688     } catch (std::exception& e) {
39689       {
39690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39691       };
39692     } catch (Dali::DaliException e) {
39693       {
39694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39695       };
39696     } catch (...) {
39697       {
39698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39699       };
39700     }
39701   }
39702
39703   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39704   return jresult;
39705 }
39706
39707
39708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39709   float jresult ;
39710   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39711   Dali::Actor *arg2 = 0 ;
39712   Dali::Dimension::Type arg3 ;
39713   float result;
39714
39715   arg1 = (Dali::CustomActorImpl *)jarg1;
39716   arg2 = (Dali::Actor *)jarg2;
39717   if (!arg2) {
39718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39719     return 0;
39720   }
39721   arg3 = (Dali::Dimension::Type)jarg3;
39722   {
39723     try {
39724       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39725     } catch (std::out_of_range& e) {
39726       {
39727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39728       };
39729     } catch (std::exception& e) {
39730       {
39731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39732       };
39733     } catch (Dali::DaliException e) {
39734       {
39735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39736       };
39737     } catch (...) {
39738       {
39739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39740       };
39741     }
39742   }
39743
39744   jresult = result;
39745   return jresult;
39746 }
39747
39748
39749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39750   float jresult ;
39751   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39752   float arg2 ;
39753   float result;
39754
39755   arg1 = (Dali::CustomActorImpl *)jarg1;
39756   arg2 = (float)jarg2;
39757   {
39758     try {
39759       result = (float)(arg1)->GetHeightForWidth(arg2);
39760     } catch (std::out_of_range& e) {
39761       {
39762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39763       };
39764     } catch (std::exception& e) {
39765       {
39766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39767       };
39768     } catch (Dali::DaliException e) {
39769       {
39770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39771       };
39772     } catch (...) {
39773       {
39774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39775       };
39776     }
39777   }
39778
39779   jresult = result;
39780   return jresult;
39781 }
39782
39783
39784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39785   float jresult ;
39786   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39787   float arg2 ;
39788   float result;
39789
39790   arg1 = (Dali::CustomActorImpl *)jarg1;
39791   arg2 = (float)jarg2;
39792   {
39793     try {
39794       result = (float)(arg1)->GetWidthForHeight(arg2);
39795     } catch (std::out_of_range& e) {
39796       {
39797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39798       };
39799     } catch (std::exception& e) {
39800       {
39801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39802       };
39803     } catch (Dali::DaliException e) {
39804       {
39805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39806       };
39807     } catch (...) {
39808       {
39809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39810       };
39811     }
39812   }
39813
39814   jresult = result;
39815   return jresult;
39816 }
39817
39818
39819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39820   unsigned int jresult ;
39821   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39822   Dali::Dimension::Type arg2 ;
39823   bool result;
39824
39825   arg1 = (Dali::CustomActorImpl *)jarg1;
39826   arg2 = (Dali::Dimension::Type)jarg2;
39827   {
39828     try {
39829       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39830     } catch (std::out_of_range& e) {
39831       {
39832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39833       };
39834     } catch (std::exception& e) {
39835       {
39836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39837       };
39838     } catch (Dali::DaliException e) {
39839       {
39840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39841       };
39842     } catch (...) {
39843       {
39844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39845       };
39846     }
39847   }
39848
39849   jresult = result;
39850   return jresult;
39851 }
39852
39853
39854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39855   unsigned int jresult ;
39856   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39857   bool result;
39858
39859   arg1 = (Dali::CustomActorImpl *)jarg1;
39860   {
39861     try {
39862       result = (bool)(arg1)->RelayoutDependentOnChildren();
39863     } catch (std::out_of_range& e) {
39864       {
39865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39866       };
39867     } catch (std::exception& e) {
39868       {
39869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39870       };
39871     } catch (Dali::DaliException e) {
39872       {
39873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39874       };
39875     } catch (...) {
39876       {
39877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39878       };
39879     }
39880   }
39881
39882   jresult = result;
39883   return jresult;
39884 }
39885
39886
39887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39888   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39889   Dali::Dimension::Type arg2 ;
39890
39891   arg1 = (Dali::CustomActorImpl *)jarg1;
39892   arg2 = (Dali::Dimension::Type)jarg2;
39893   {
39894     try {
39895       (arg1)->OnCalculateRelayoutSize(arg2);
39896     } catch (std::out_of_range& e) {
39897       {
39898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39899       };
39900     } catch (std::exception& e) {
39901       {
39902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39903       };
39904     } catch (Dali::DaliException e) {
39905       {
39906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39907       };
39908     } catch (...) {
39909       {
39910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39911       };
39912     }
39913   }
39914
39915 }
39916
39917
39918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39919   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39920   float arg2 ;
39921   Dali::Dimension::Type arg3 ;
39922
39923   arg1 = (Dali::CustomActorImpl *)jarg1;
39924   arg2 = (float)jarg2;
39925   arg3 = (Dali::Dimension::Type)jarg3;
39926   {
39927     try {
39928       (arg1)->OnLayoutNegotiated(arg2,arg3);
39929     } catch (std::out_of_range& e) {
39930       {
39931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39932       };
39933     } catch (std::exception& e) {
39934       {
39935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39936       };
39937     } catch (Dali::DaliException e) {
39938       {
39939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39940       };
39941     } catch (...) {
39942       {
39943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39944       };
39945     }
39946   }
39947
39948 }
39949
39950
39951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39952   unsigned int jresult ;
39953   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39954   bool result;
39955
39956   arg1 = (Dali::CustomActorImpl *)jarg1;
39957   {
39958     try {
39959       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39960     } catch (std::out_of_range& e) {
39961       {
39962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39963       };
39964     } catch (std::exception& e) {
39965       {
39966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39967       };
39968     } catch (Dali::DaliException e) {
39969       {
39970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39971       };
39972     } catch (...) {
39973       {
39974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39975       };
39976     }
39977   }
39978
39979   jresult = result;
39980   return jresult;
39981 }
39982
39983
39984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39985   unsigned int jresult ;
39986   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39987   bool result;
39988
39989   arg1 = (Dali::CustomActorImpl *)jarg1;
39990   {
39991     try {
39992       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39993     } catch (std::out_of_range& e) {
39994       {
39995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39996       };
39997     } catch (std::exception& e) {
39998       {
39999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40000       };
40001     } catch (Dali::DaliException e) {
40002       {
40003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40004       };
40005     } catch (...) {
40006       {
40007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40008       };
40009     }
40010   }
40011
40012   jresult = result;
40013   return jresult;
40014 }
40015
40016
40017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40018   unsigned int jresult ;
40019   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40020   bool result;
40021
40022   arg1 = (Dali::CustomActorImpl *)jarg1;
40023   {
40024     try {
40025       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40026     } catch (std::out_of_range& e) {
40027       {
40028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40029       };
40030     } catch (std::exception& e) {
40031       {
40032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40033       };
40034     } catch (Dali::DaliException e) {
40035       {
40036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40037       };
40038     } catch (...) {
40039       {
40040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40041       };
40042     }
40043   }
40044
40045   jresult = result;
40046   return jresult;
40047 }
40048
40049
40050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40051   unsigned int jresult ;
40052   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40053   bool result;
40054
40055   arg1 = (Dali::CustomActorImpl *)jarg1;
40056   {
40057     try {
40058       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40059     } catch (std::out_of_range& e) {
40060       {
40061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40062       };
40063     } catch (std::exception& e) {
40064       {
40065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40066       };
40067     } catch (Dali::DaliException e) {
40068       {
40069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40070       };
40071     } catch (...) {
40072       {
40073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40074       };
40075     }
40076   }
40077
40078   jresult = result;
40079   return jresult;
40080 }
40081
40082
40083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40084   void * jresult ;
40085   Dali::CustomActor *result = 0 ;
40086
40087   {
40088     try {
40089       result = (Dali::CustomActor *)new Dali::CustomActor();
40090     } catch (std::out_of_range& e) {
40091       {
40092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40093       };
40094     } catch (std::exception& e) {
40095       {
40096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40097       };
40098     } catch (Dali::DaliException e) {
40099       {
40100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40101       };
40102     } catch (...) {
40103       {
40104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40105       };
40106     }
40107   }
40108
40109   jresult = (void *)result;
40110   return jresult;
40111 }
40112
40113
40114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40115   void * jresult ;
40116   Dali::BaseHandle arg1 ;
40117   Dali::BaseHandle *argp1 ;
40118   Dali::CustomActor result;
40119
40120   argp1 = (Dali::BaseHandle *)jarg1;
40121   if (!argp1) {
40122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40123     return 0;
40124   }
40125   arg1 = *argp1;
40126   {
40127     try {
40128       result = Dali::CustomActor::DownCast(arg1);
40129     } catch (std::out_of_range& e) {
40130       {
40131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40132       };
40133     } catch (std::exception& e) {
40134       {
40135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40136       };
40137     } catch (Dali::DaliException e) {
40138       {
40139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40140       };
40141     } catch (...) {
40142       {
40143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40144       };
40145     }
40146   }
40147
40148   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40149   return jresult;
40150 }
40151
40152
40153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40154   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40155
40156   arg1 = (Dali::CustomActor *)jarg1;
40157   {
40158     try {
40159       delete arg1;
40160     } catch (std::out_of_range& e) {
40161       {
40162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40163       };
40164     } catch (std::exception& e) {
40165       {
40166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40167       };
40168     } catch (Dali::DaliException e) {
40169       {
40170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40171       };
40172     } catch (...) {
40173       {
40174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40175       };
40176     }
40177   }
40178
40179 }
40180
40181
40182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40183   void * jresult ;
40184   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40185   Dali::CustomActorImpl *result = 0 ;
40186
40187   arg1 = (Dali::CustomActor *)jarg1;
40188   {
40189     try {
40190       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40191     } catch (std::out_of_range& e) {
40192       {
40193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40194       };
40195     } catch (std::exception& e) {
40196       {
40197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40198       };
40199     } catch (Dali::DaliException e) {
40200       {
40201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40202       };
40203     } catch (...) {
40204       {
40205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40206       };
40207     }
40208   }
40209
40210   jresult = (void *)result;
40211   return jresult;
40212 }
40213
40214
40215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40216   void * jresult ;
40217   Dali::CustomActorImpl *arg1 = 0 ;
40218   Dali::CustomActor *result = 0 ;
40219
40220   arg1 = (Dali::CustomActorImpl *)jarg1;
40221   if (!arg1) {
40222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40223     return 0;
40224   }
40225   {
40226     try {
40227       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40228     } catch (std::out_of_range& e) {
40229       {
40230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40231       };
40232     } catch (std::exception& e) {
40233       {
40234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40235       };
40236     } catch (Dali::DaliException e) {
40237       {
40238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40239       };
40240     } catch (...) {
40241       {
40242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40243       };
40244     }
40245   }
40246
40247   jresult = (void *)result;
40248   return jresult;
40249 }
40250
40251
40252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40253   void * jresult ;
40254   Dali::CustomActor *arg1 = 0 ;
40255   Dali::CustomActor *result = 0 ;
40256
40257   arg1 = (Dali::CustomActor *)jarg1;
40258   if (!arg1) {
40259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40260     return 0;
40261   }
40262   {
40263     try {
40264       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40265     } catch (std::out_of_range& e) {
40266       {
40267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40268       };
40269     } catch (std::exception& e) {
40270       {
40271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40272       };
40273     } catch (Dali::DaliException e) {
40274       {
40275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40276       };
40277     } catch (...) {
40278       {
40279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40280       };
40281     }
40282   }
40283
40284   jresult = (void *)result;
40285   return jresult;
40286 }
40287
40288
40289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40290   void * jresult ;
40291   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40292   Dali::CustomActor *arg2 = 0 ;
40293   Dali::CustomActor *result = 0 ;
40294
40295   arg1 = (Dali::CustomActor *)jarg1;
40296   arg2 = (Dali::CustomActor *)jarg2;
40297   if (!arg2) {
40298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40299     return 0;
40300   }
40301   {
40302     try {
40303       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40304     } catch (std::out_of_range& e) {
40305       {
40306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40307       };
40308     } catch (std::exception& e) {
40309       {
40310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40311       };
40312     } catch (Dali::DaliException e) {
40313       {
40314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40315       };
40316     } catch (...) {
40317       {
40318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40319       };
40320     }
40321   }
40322
40323   jresult = (void *)result;
40324   return jresult;
40325 }
40326
40327
40328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40329   int jresult ;
40330   int result;
40331
40332   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40333   jresult = (int)result;
40334   return jresult;
40335 }
40336
40337
40338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40339   int jresult ;
40340   int result;
40341
40342   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40343   jresult = (int)result;
40344   return jresult;
40345 }
40346
40347
40348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40349   int jresult ;
40350   int result;
40351
40352   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40353   jresult = (int)result;
40354   return jresult;
40355 }
40356
40357
40358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40359   int jresult ;
40360   int result;
40361
40362   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40363   jresult = (int)result;
40364   return jresult;
40365 }
40366
40367
40368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40369   int jresult ;
40370   int result;
40371
40372   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40373   jresult = (int)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40379   int jresult ;
40380   int result;
40381
40382   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40383   jresult = (int)result;
40384   return jresult;
40385 }
40386
40387
40388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40389   int jresult ;
40390   int result;
40391
40392   result = (int)Dali::PanGestureDetector::Property::PANNING;
40393   jresult = (int)result;
40394   return jresult;
40395 }
40396
40397
40398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40399   void * jresult ;
40400   Dali::PanGestureDetector::Property *result = 0 ;
40401
40402   {
40403     try {
40404       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40405     } catch (std::out_of_range& e) {
40406       {
40407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40408       };
40409     } catch (std::exception& e) {
40410       {
40411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40412       };
40413     } catch (Dali::DaliException e) {
40414       {
40415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40416       };
40417     } catch (...) {
40418       {
40419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40420       };
40421     }
40422   }
40423
40424   jresult = (void *)result;
40425   return jresult;
40426 }
40427
40428
40429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40430   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40431
40432   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40433   {
40434     try {
40435       delete arg1;
40436     } catch (std::out_of_range& e) {
40437       {
40438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40439       };
40440     } catch (std::exception& e) {
40441       {
40442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40443       };
40444     } catch (Dali::DaliException e) {
40445       {
40446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40447       };
40448     } catch (...) {
40449       {
40450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40451       };
40452     }
40453   }
40454
40455 }
40456
40457
40458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40459   void * jresult ;
40460   Dali::Radian *result = 0 ;
40461
40462   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40463   jresult = (void *)result;
40464   return jresult;
40465 }
40466
40467
40468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40469   void * jresult ;
40470   Dali::Radian *result = 0 ;
40471
40472   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40473   jresult = (void *)result;
40474   return jresult;
40475 }
40476
40477
40478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40479   void * jresult ;
40480   Dali::Radian *result = 0 ;
40481
40482   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40483   jresult = (void *)result;
40484   return jresult;
40485 }
40486
40487
40488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40489   void * jresult ;
40490   Dali::Radian *result = 0 ;
40491
40492   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40493   jresult = (void *)result;
40494   return jresult;
40495 }
40496
40497
40498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40499   void * jresult ;
40500   Dali::Radian *result = 0 ;
40501
40502   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40503   jresult = (void *)result;
40504   return jresult;
40505 }
40506
40507
40508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40509   void * jresult ;
40510   Dali::Radian *result = 0 ;
40511
40512   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40513   jresult = (void *)result;
40514   return jresult;
40515 }
40516
40517
40518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40519   void * jresult ;
40520   Dali::Radian *result = 0 ;
40521
40522   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40523   jresult = (void *)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40529   void * jresult ;
40530   Dali::PanGestureDetector *result = 0 ;
40531
40532   {
40533     try {
40534       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40535     } catch (std::out_of_range& e) {
40536       {
40537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40538       };
40539     } catch (std::exception& e) {
40540       {
40541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40542       };
40543     } catch (Dali::DaliException e) {
40544       {
40545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40546       };
40547     } catch (...) {
40548       {
40549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40550       };
40551     }
40552   }
40553
40554   jresult = (void *)result;
40555   return jresult;
40556 }
40557
40558
40559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40560   void * jresult ;
40561   Dali::PanGestureDetector result;
40562
40563   {
40564     try {
40565       result = Dali::PanGestureDetector::New();
40566     } catch (std::out_of_range& e) {
40567       {
40568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40569       };
40570     } catch (std::exception& e) {
40571       {
40572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40573       };
40574     } catch (Dali::DaliException e) {
40575       {
40576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40577       };
40578     } catch (...) {
40579       {
40580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40581       };
40582     }
40583   }
40584
40585   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40586   return jresult;
40587 }
40588
40589
40590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40591   void * jresult ;
40592   Dali::BaseHandle arg1 ;
40593   Dali::BaseHandle *argp1 ;
40594   Dali::PanGestureDetector result;
40595
40596   argp1 = (Dali::BaseHandle *)jarg1;
40597   if (!argp1) {
40598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40599     return 0;
40600   }
40601   arg1 = *argp1;
40602   {
40603     try {
40604       result = Dali::PanGestureDetector::DownCast(arg1);
40605     } catch (std::out_of_range& e) {
40606       {
40607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40608       };
40609     } catch (std::exception& e) {
40610       {
40611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40612       };
40613     } catch (Dali::DaliException e) {
40614       {
40615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40616       };
40617     } catch (...) {
40618       {
40619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40620       };
40621     }
40622   }
40623
40624   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40625   return jresult;
40626 }
40627
40628
40629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40630   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40631
40632   arg1 = (Dali::PanGestureDetector *)jarg1;
40633   {
40634     try {
40635       delete arg1;
40636     } catch (std::out_of_range& e) {
40637       {
40638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40639       };
40640     } catch (std::exception& e) {
40641       {
40642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40643       };
40644     } catch (Dali::DaliException e) {
40645       {
40646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40647       };
40648     } catch (...) {
40649       {
40650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40651       };
40652     }
40653   }
40654
40655 }
40656
40657
40658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40659   void * jresult ;
40660   Dali::PanGestureDetector *arg1 = 0 ;
40661   Dali::PanGestureDetector *result = 0 ;
40662
40663   arg1 = (Dali::PanGestureDetector *)jarg1;
40664   if (!arg1) {
40665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40666     return 0;
40667   }
40668   {
40669     try {
40670       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40671     } catch (std::out_of_range& e) {
40672       {
40673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40674       };
40675     } catch (std::exception& e) {
40676       {
40677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40678       };
40679     } catch (Dali::DaliException e) {
40680       {
40681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40682       };
40683     } catch (...) {
40684       {
40685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40686       };
40687     }
40688   }
40689
40690   jresult = (void *)result;
40691   return jresult;
40692 }
40693
40694
40695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40696   void * jresult ;
40697   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40698   Dali::PanGestureDetector *arg2 = 0 ;
40699   Dali::PanGestureDetector *result = 0 ;
40700
40701   arg1 = (Dali::PanGestureDetector *)jarg1;
40702   arg2 = (Dali::PanGestureDetector *)jarg2;
40703   if (!arg2) {
40704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40705     return 0;
40706   }
40707   {
40708     try {
40709       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40710     } catch (std::out_of_range& e) {
40711       {
40712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40713       };
40714     } catch (std::exception& e) {
40715       {
40716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40717       };
40718     } catch (Dali::DaliException e) {
40719       {
40720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40721       };
40722     } catch (...) {
40723       {
40724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40725       };
40726     }
40727   }
40728
40729   jresult = (void *)result;
40730   return jresult;
40731 }
40732
40733
40734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40735   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40736   unsigned int arg2 ;
40737
40738   arg1 = (Dali::PanGestureDetector *)jarg1;
40739   arg2 = (unsigned int)jarg2;
40740   {
40741     try {
40742       (arg1)->SetMinimumTouchesRequired(arg2);
40743     } catch (std::out_of_range& e) {
40744       {
40745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40746       };
40747     } catch (std::exception& e) {
40748       {
40749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40750       };
40751     } catch (Dali::DaliException e) {
40752       {
40753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40754       };
40755     } catch (...) {
40756       {
40757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40758       };
40759     }
40760   }
40761
40762 }
40763
40764
40765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40766   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40767   unsigned int arg2 ;
40768
40769   arg1 = (Dali::PanGestureDetector *)jarg1;
40770   arg2 = (unsigned int)jarg2;
40771   {
40772     try {
40773       (arg1)->SetMaximumTouchesRequired(arg2);
40774     } catch (std::out_of_range& e) {
40775       {
40776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40777       };
40778     } catch (std::exception& e) {
40779       {
40780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40781       };
40782     } catch (Dali::DaliException e) {
40783       {
40784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40785       };
40786     } catch (...) {
40787       {
40788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40789       };
40790     }
40791   }
40792
40793 }
40794
40795
40796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40797   unsigned int jresult ;
40798   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40799   unsigned int result;
40800
40801   arg1 = (Dali::PanGestureDetector *)jarg1;
40802   {
40803     try {
40804       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40805     } catch (std::out_of_range& e) {
40806       {
40807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40808       };
40809     } catch (std::exception& e) {
40810       {
40811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40812       };
40813     } catch (Dali::DaliException e) {
40814       {
40815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40816       };
40817     } catch (...) {
40818       {
40819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40820       };
40821     }
40822   }
40823
40824   jresult = result;
40825   return jresult;
40826 }
40827
40828
40829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40830   unsigned int jresult ;
40831   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40832   unsigned int result;
40833
40834   arg1 = (Dali::PanGestureDetector *)jarg1;
40835   {
40836     try {
40837       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40838     } catch (std::out_of_range& e) {
40839       {
40840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40841       };
40842     } catch (std::exception& e) {
40843       {
40844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40845       };
40846     } catch (Dali::DaliException e) {
40847       {
40848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40849       };
40850     } catch (...) {
40851       {
40852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40853       };
40854     }
40855   }
40856
40857   jresult = result;
40858   return jresult;
40859 }
40860
40861
40862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40863   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40864   Dali::Radian arg2 ;
40865   Dali::Radian arg3 ;
40866   Dali::Radian *argp2 ;
40867   Dali::Radian *argp3 ;
40868
40869   arg1 = (Dali::PanGestureDetector *)jarg1;
40870   argp2 = (Dali::Radian *)jarg2;
40871   if (!argp2) {
40872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40873     return ;
40874   }
40875   arg2 = *argp2;
40876   argp3 = (Dali::Radian *)jarg3;
40877   if (!argp3) {
40878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40879     return ;
40880   }
40881   arg3 = *argp3;
40882   {
40883     try {
40884       (arg1)->AddAngle(arg2,arg3);
40885     } catch (std::out_of_range& e) {
40886       {
40887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40888       };
40889     } catch (std::exception& e) {
40890       {
40891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40892       };
40893     } catch (Dali::DaliException e) {
40894       {
40895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40896       };
40897     } catch (...) {
40898       {
40899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40900       };
40901     }
40902   }
40903
40904 }
40905
40906
40907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40908   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40909   Dali::Radian arg2 ;
40910   Dali::Radian *argp2 ;
40911
40912   arg1 = (Dali::PanGestureDetector *)jarg1;
40913   argp2 = (Dali::Radian *)jarg2;
40914   if (!argp2) {
40915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40916     return ;
40917   }
40918   arg2 = *argp2;
40919   {
40920     try {
40921       (arg1)->AddAngle(arg2);
40922     } catch (std::out_of_range& e) {
40923       {
40924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40925       };
40926     } catch (std::exception& e) {
40927       {
40928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40929       };
40930     } catch (Dali::DaliException e) {
40931       {
40932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40933       };
40934     } catch (...) {
40935       {
40936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40937       };
40938     }
40939   }
40940
40941 }
40942
40943
40944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40945   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40946   Dali::Radian arg2 ;
40947   Dali::Radian arg3 ;
40948   Dali::Radian *argp2 ;
40949   Dali::Radian *argp3 ;
40950
40951   arg1 = (Dali::PanGestureDetector *)jarg1;
40952   argp2 = (Dali::Radian *)jarg2;
40953   if (!argp2) {
40954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40955     return ;
40956   }
40957   arg2 = *argp2;
40958   argp3 = (Dali::Radian *)jarg3;
40959   if (!argp3) {
40960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40961     return ;
40962   }
40963   arg3 = *argp3;
40964   {
40965     try {
40966       (arg1)->AddDirection(arg2,arg3);
40967     } catch (std::out_of_range& e) {
40968       {
40969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40970       };
40971     } catch (std::exception& e) {
40972       {
40973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40974       };
40975     } catch (Dali::DaliException e) {
40976       {
40977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40978       };
40979     } catch (...) {
40980       {
40981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40982       };
40983     }
40984   }
40985
40986 }
40987
40988
40989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40990   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40991   Dali::Radian arg2 ;
40992   Dali::Radian *argp2 ;
40993
40994   arg1 = (Dali::PanGestureDetector *)jarg1;
40995   argp2 = (Dali::Radian *)jarg2;
40996   if (!argp2) {
40997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40998     return ;
40999   }
41000   arg2 = *argp2;
41001   {
41002     try {
41003       (arg1)->AddDirection(arg2);
41004     } catch (std::out_of_range& e) {
41005       {
41006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41007       };
41008     } catch (std::exception& e) {
41009       {
41010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41011       };
41012     } catch (Dali::DaliException e) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41015       };
41016     } catch (...) {
41017       {
41018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41019       };
41020     }
41021   }
41022
41023 }
41024
41025
41026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41027   unsigned long jresult ;
41028   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41029   size_t result;
41030
41031   arg1 = (Dali::PanGestureDetector *)jarg1;
41032   {
41033     try {
41034       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41035     } catch (std::out_of_range& e) {
41036       {
41037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41038       };
41039     } catch (std::exception& e) {
41040       {
41041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41042       };
41043     } catch (Dali::DaliException e) {
41044       {
41045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41046       };
41047     } catch (...) {
41048       {
41049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41050       };
41051     }
41052   }
41053
41054   jresult = (unsigned long)result;
41055   return jresult;
41056 }
41057
41058
41059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41060   void * jresult ;
41061   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41062   size_t arg2 ;
41063   Dali::PanGestureDetector::AngleThresholdPair result;
41064
41065   arg1 = (Dali::PanGestureDetector *)jarg1;
41066   arg2 = (size_t)jarg2;
41067   {
41068     try {
41069       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41070     } catch (std::out_of_range& e) {
41071       {
41072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41073       };
41074     } catch (std::exception& e) {
41075       {
41076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41077       };
41078     } catch (Dali::DaliException e) {
41079       {
41080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41081       };
41082     } catch (...) {
41083       {
41084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41085       };
41086     }
41087   }
41088
41089   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41090   return jresult;
41091 }
41092
41093
41094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41095   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41096
41097   arg1 = (Dali::PanGestureDetector *)jarg1;
41098   {
41099     try {
41100       (arg1)->ClearAngles();
41101     } catch (std::out_of_range& e) {
41102       {
41103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41104       };
41105     } catch (std::exception& e) {
41106       {
41107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41108       };
41109     } catch (Dali::DaliException e) {
41110       {
41111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41112       };
41113     } catch (...) {
41114       {
41115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41116       };
41117     }
41118   }
41119
41120 }
41121
41122
41123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41124   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41125   Dali::Radian arg2 ;
41126   Dali::Radian *argp2 ;
41127
41128   arg1 = (Dali::PanGestureDetector *)jarg1;
41129   argp2 = (Dali::Radian *)jarg2;
41130   if (!argp2) {
41131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41132     return ;
41133   }
41134   arg2 = *argp2;
41135   {
41136     try {
41137       (arg1)->RemoveAngle(arg2);
41138     } catch (std::out_of_range& e) {
41139       {
41140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41141       };
41142     } catch (std::exception& e) {
41143       {
41144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41145       };
41146     } catch (Dali::DaliException e) {
41147       {
41148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41149       };
41150     } catch (...) {
41151       {
41152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41153       };
41154     }
41155   }
41156
41157 }
41158
41159
41160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41161   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41162   Dali::Radian arg2 ;
41163   Dali::Radian *argp2 ;
41164
41165   arg1 = (Dali::PanGestureDetector *)jarg1;
41166   argp2 = (Dali::Radian *)jarg2;
41167   if (!argp2) {
41168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41169     return ;
41170   }
41171   arg2 = *argp2;
41172   {
41173     try {
41174       (arg1)->RemoveDirection(arg2);
41175     } catch (std::out_of_range& e) {
41176       {
41177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41178       };
41179     } catch (std::exception& e) {
41180       {
41181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41182       };
41183     } catch (Dali::DaliException e) {
41184       {
41185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41186       };
41187     } catch (...) {
41188       {
41189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41190       };
41191     }
41192   }
41193
41194 }
41195
41196
41197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41198   void * jresult ;
41199   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41200   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41201
41202   arg1 = (Dali::PanGestureDetector *)jarg1;
41203   {
41204     try {
41205       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41206     } catch (std::out_of_range& e) {
41207       {
41208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41209       };
41210     } catch (std::exception& e) {
41211       {
41212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41213       };
41214     } catch (Dali::DaliException e) {
41215       {
41216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41217       };
41218     } catch (...) {
41219       {
41220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41221       };
41222     }
41223   }
41224
41225   jresult = (void *)result;
41226   return jresult;
41227 }
41228
41229
41230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41231   Dali::PanGesture *arg1 = 0 ;
41232
41233   arg1 = (Dali::PanGesture *)jarg1;
41234   if (!arg1) {
41235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41236     return ;
41237   }
41238   {
41239     try {
41240       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41241     } catch (std::out_of_range& e) {
41242       {
41243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41244       };
41245     } catch (std::exception& e) {
41246       {
41247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41248       };
41249     } catch (Dali::DaliException e) {
41250       {
41251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41252       };
41253     } catch (...) {
41254       {
41255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41256       };
41257     }
41258   }
41259
41260 }
41261
41262
41263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41264   void * jresult ;
41265   Dali::PanGesture *result = 0 ;
41266
41267   {
41268     try {
41269       result = (Dali::PanGesture *)new Dali::PanGesture();
41270     } catch (std::out_of_range& e) {
41271       {
41272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41273       };
41274     } catch (std::exception& e) {
41275       {
41276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41277       };
41278     } catch (Dali::DaliException e) {
41279       {
41280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41281       };
41282     } catch (...) {
41283       {
41284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41285       };
41286     }
41287   }
41288
41289   jresult = (void *)result;
41290   return jresult;
41291 }
41292
41293
41294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41295   void * jresult ;
41296   Dali::Gesture::State arg1 ;
41297   Dali::PanGesture *result = 0 ;
41298
41299   arg1 = (Dali::Gesture::State)jarg1;
41300   {
41301     try {
41302       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41303     } catch (std::out_of_range& e) {
41304       {
41305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41306       };
41307     } catch (std::exception& e) {
41308       {
41309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41310       };
41311     } catch (Dali::DaliException e) {
41312       {
41313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41314       };
41315     } catch (...) {
41316       {
41317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41318       };
41319     }
41320   }
41321
41322   jresult = (void *)result;
41323   return jresult;
41324 }
41325
41326
41327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41328   void * jresult ;
41329   Dali::PanGesture *arg1 = 0 ;
41330   Dali::PanGesture *result = 0 ;
41331
41332   arg1 = (Dali::PanGesture *)jarg1;
41333   if (!arg1) {
41334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41335     return 0;
41336   }
41337   {
41338     try {
41339       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41340     } catch (std::out_of_range& e) {
41341       {
41342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (std::exception& e) {
41345       {
41346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41347       };
41348     } catch (Dali::DaliException e) {
41349       {
41350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41351       };
41352     } catch (...) {
41353       {
41354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41355       };
41356     }
41357   }
41358
41359   jresult = (void *)result;
41360   return jresult;
41361 }
41362
41363
41364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41365   void * jresult ;
41366   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41367   Dali::PanGesture *arg2 = 0 ;
41368   Dali::PanGesture *result = 0 ;
41369
41370   arg1 = (Dali::PanGesture *)jarg1;
41371   arg2 = (Dali::PanGesture *)jarg2;
41372   if (!arg2) {
41373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41374     return 0;
41375   }
41376   {
41377     try {
41378       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41379     } catch (std::out_of_range& e) {
41380       {
41381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41382       };
41383     } catch (std::exception& e) {
41384       {
41385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (Dali::DaliException e) {
41388       {
41389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41390       };
41391     } catch (...) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41394       };
41395     }
41396   }
41397
41398   jresult = (void *)result;
41399   return jresult;
41400 }
41401
41402
41403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41404   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41405
41406   arg1 = (Dali::PanGesture *)jarg1;
41407   {
41408     try {
41409       delete arg1;
41410     } catch (std::out_of_range& e) {
41411       {
41412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41413       };
41414     } catch (std::exception& e) {
41415       {
41416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41417       };
41418     } catch (Dali::DaliException e) {
41419       {
41420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41421       };
41422     } catch (...) {
41423       {
41424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41425       };
41426     }
41427   }
41428
41429 }
41430
41431
41432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41433   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41434   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41435
41436   arg1 = (Dali::PanGesture *)jarg1;
41437   arg2 = (Dali::Vector2 *)jarg2;
41438   if (arg1) (arg1)->velocity = *arg2;
41439 }
41440
41441
41442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41443   void * jresult ;
41444   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41445   Dali::Vector2 *result = 0 ;
41446
41447   arg1 = (Dali::PanGesture *)jarg1;
41448   result = (Dali::Vector2 *)& ((arg1)->velocity);
41449   jresult = (void *)result;
41450   return jresult;
41451 }
41452
41453
41454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41455   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41456   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41457
41458   arg1 = (Dali::PanGesture *)jarg1;
41459   arg2 = (Dali::Vector2 *)jarg2;
41460   if (arg1) (arg1)->displacement = *arg2;
41461 }
41462
41463
41464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41465   void * jresult ;
41466   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41467   Dali::Vector2 *result = 0 ;
41468
41469   arg1 = (Dali::PanGesture *)jarg1;
41470   result = (Dali::Vector2 *)& ((arg1)->displacement);
41471   jresult = (void *)result;
41472   return jresult;
41473 }
41474
41475
41476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41477   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41478   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41479
41480   arg1 = (Dali::PanGesture *)jarg1;
41481   arg2 = (Dali::Vector2 *)jarg2;
41482   if (arg1) (arg1)->position = *arg2;
41483 }
41484
41485
41486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41487   void * jresult ;
41488   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41489   Dali::Vector2 *result = 0 ;
41490
41491   arg1 = (Dali::PanGesture *)jarg1;
41492   result = (Dali::Vector2 *)& ((arg1)->position);
41493   jresult = (void *)result;
41494   return jresult;
41495 }
41496
41497
41498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41499   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41500   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41501
41502   arg1 = (Dali::PanGesture *)jarg1;
41503   arg2 = (Dali::Vector2 *)jarg2;
41504   if (arg1) (arg1)->screenVelocity = *arg2;
41505 }
41506
41507
41508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41509   void * jresult ;
41510   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41511   Dali::Vector2 *result = 0 ;
41512
41513   arg1 = (Dali::PanGesture *)jarg1;
41514   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41515   jresult = (void *)result;
41516   return jresult;
41517 }
41518
41519
41520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41521   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41522   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41523
41524   arg1 = (Dali::PanGesture *)jarg1;
41525   arg2 = (Dali::Vector2 *)jarg2;
41526   if (arg1) (arg1)->screenDisplacement = *arg2;
41527 }
41528
41529
41530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41531   void * jresult ;
41532   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41533   Dali::Vector2 *result = 0 ;
41534
41535   arg1 = (Dali::PanGesture *)jarg1;
41536   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41537   jresult = (void *)result;
41538   return jresult;
41539 }
41540
41541
41542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41543   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41544   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41545
41546   arg1 = (Dali::PanGesture *)jarg1;
41547   arg2 = (Dali::Vector2 *)jarg2;
41548   if (arg1) (arg1)->screenPosition = *arg2;
41549 }
41550
41551
41552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41553   void * jresult ;
41554   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41555   Dali::Vector2 *result = 0 ;
41556
41557   arg1 = (Dali::PanGesture *)jarg1;
41558   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41559   jresult = (void *)result;
41560   return jresult;
41561 }
41562
41563
41564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41565   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41566   unsigned int arg2 ;
41567
41568   arg1 = (Dali::PanGesture *)jarg1;
41569   arg2 = (unsigned int)jarg2;
41570   if (arg1) (arg1)->numberOfTouches = arg2;
41571 }
41572
41573
41574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41575   unsigned int jresult ;
41576   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41577   unsigned int result;
41578
41579   arg1 = (Dali::PanGesture *)jarg1;
41580   result = (unsigned int) ((arg1)->numberOfTouches);
41581   jresult = result;
41582   return jresult;
41583 }
41584
41585
41586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41587   float jresult ;
41588   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41589   float result;
41590
41591   arg1 = (Dali::PanGesture *)jarg1;
41592   {
41593     try {
41594       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41595     } catch (std::out_of_range& e) {
41596       {
41597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41598       };
41599     } catch (std::exception& e) {
41600       {
41601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41602       };
41603     } catch (Dali::DaliException e) {
41604       {
41605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41606       };
41607     } catch (...) {
41608       {
41609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41610       };
41611     }
41612   }
41613
41614   jresult = result;
41615   return jresult;
41616 }
41617
41618
41619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41620   float jresult ;
41621   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41622   float result;
41623
41624   arg1 = (Dali::PanGesture *)jarg1;
41625   {
41626     try {
41627       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41628     } catch (std::out_of_range& e) {
41629       {
41630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41631       };
41632     } catch (std::exception& e) {
41633       {
41634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41635       };
41636     } catch (Dali::DaliException e) {
41637       {
41638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41639       };
41640     } catch (...) {
41641       {
41642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41643       };
41644     }
41645   }
41646
41647   jresult = result;
41648   return jresult;
41649 }
41650
41651
41652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41653   float jresult ;
41654   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41655   float result;
41656
41657   arg1 = (Dali::PanGesture *)jarg1;
41658   {
41659     try {
41660       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41661     } catch (std::out_of_range& e) {
41662       {
41663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41664       };
41665     } catch (std::exception& e) {
41666       {
41667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41668       };
41669     } catch (Dali::DaliException e) {
41670       {
41671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41672       };
41673     } catch (...) {
41674       {
41675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41676       };
41677     }
41678   }
41679
41680   jresult = result;
41681   return jresult;
41682 }
41683
41684
41685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41686   float jresult ;
41687   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41688   float result;
41689
41690   arg1 = (Dali::PanGesture *)jarg1;
41691   {
41692     try {
41693       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41694     } catch (std::out_of_range& e) {
41695       {
41696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41697       };
41698     } catch (std::exception& e) {
41699       {
41700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41701       };
41702     } catch (Dali::DaliException e) {
41703       {
41704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41705       };
41706     } catch (...) {
41707       {
41708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41709       };
41710     }
41711   }
41712
41713   jresult = result;
41714   return jresult;
41715 }
41716
41717
41718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41719   void * jresult ;
41720   Dali::PinchGestureDetector *result = 0 ;
41721
41722   {
41723     try {
41724       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41725     } catch (std::out_of_range& e) {
41726       {
41727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41728       };
41729     } catch (std::exception& e) {
41730       {
41731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41732       };
41733     } catch (Dali::DaliException e) {
41734       {
41735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41736       };
41737     } catch (...) {
41738       {
41739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41740       };
41741     }
41742   }
41743
41744   jresult = (void *)result;
41745   return jresult;
41746 }
41747
41748
41749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41750   void * jresult ;
41751   Dali::PinchGestureDetector result;
41752
41753   {
41754     try {
41755       result = Dali::PinchGestureDetector::New();
41756     } catch (std::out_of_range& e) {
41757       {
41758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41759       };
41760     } catch (std::exception& e) {
41761       {
41762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (Dali::DaliException e) {
41765       {
41766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41767       };
41768     } catch (...) {
41769       {
41770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41771       };
41772     }
41773   }
41774
41775   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41776   return jresult;
41777 }
41778
41779
41780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41781   void * jresult ;
41782   Dali::BaseHandle arg1 ;
41783   Dali::BaseHandle *argp1 ;
41784   Dali::PinchGestureDetector result;
41785
41786   argp1 = (Dali::BaseHandle *)jarg1;
41787   if (!argp1) {
41788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41789     return 0;
41790   }
41791   arg1 = *argp1;
41792   {
41793     try {
41794       result = Dali::PinchGestureDetector::DownCast(arg1);
41795     } catch (std::out_of_range& e) {
41796       {
41797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41798       };
41799     } catch (std::exception& e) {
41800       {
41801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41802       };
41803     } catch (Dali::DaliException e) {
41804       {
41805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41806       };
41807     } catch (...) {
41808       {
41809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41810       };
41811     }
41812   }
41813
41814   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41815   return jresult;
41816 }
41817
41818
41819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41820   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41821
41822   arg1 = (Dali::PinchGestureDetector *)jarg1;
41823   {
41824     try {
41825       delete arg1;
41826     } catch (std::out_of_range& e) {
41827       {
41828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41829       };
41830     } catch (std::exception& e) {
41831       {
41832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41833       };
41834     } catch (Dali::DaliException e) {
41835       {
41836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41837       };
41838     } catch (...) {
41839       {
41840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41841       };
41842     }
41843   }
41844
41845 }
41846
41847
41848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41849   void * jresult ;
41850   Dali::PinchGestureDetector *arg1 = 0 ;
41851   Dali::PinchGestureDetector *result = 0 ;
41852
41853   arg1 = (Dali::PinchGestureDetector *)jarg1;
41854   if (!arg1) {
41855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41856     return 0;
41857   }
41858   {
41859     try {
41860       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41861     } catch (std::out_of_range& e) {
41862       {
41863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41864       };
41865     } catch (std::exception& e) {
41866       {
41867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41868       };
41869     } catch (Dali::DaliException e) {
41870       {
41871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41872       };
41873     } catch (...) {
41874       {
41875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41876       };
41877     }
41878   }
41879
41880   jresult = (void *)result;
41881   return jresult;
41882 }
41883
41884
41885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41886   void * jresult ;
41887   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41888   Dali::PinchGestureDetector *arg2 = 0 ;
41889   Dali::PinchGestureDetector *result = 0 ;
41890
41891   arg1 = (Dali::PinchGestureDetector *)jarg1;
41892   arg2 = (Dali::PinchGestureDetector *)jarg2;
41893   if (!arg2) {
41894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41895     return 0;
41896   }
41897   {
41898     try {
41899       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41900     } catch (std::out_of_range& e) {
41901       {
41902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41903       };
41904     } catch (std::exception& e) {
41905       {
41906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41907       };
41908     } catch (Dali::DaliException e) {
41909       {
41910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41911       };
41912     } catch (...) {
41913       {
41914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41915       };
41916     }
41917   }
41918
41919   jresult = (void *)result;
41920   return jresult;
41921 }
41922
41923
41924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41925   void * jresult ;
41926   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41927   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41928
41929   arg1 = (Dali::PinchGestureDetector *)jarg1;
41930   {
41931     try {
41932       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41933     } catch (std::out_of_range& e) {
41934       {
41935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41936       };
41937     } catch (std::exception& e) {
41938       {
41939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41940       };
41941     } catch (Dali::DaliException e) {
41942       {
41943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41944       };
41945     } catch (...) {
41946       {
41947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41948       };
41949     }
41950   }
41951
41952   jresult = (void *)result;
41953   return jresult;
41954 }
41955
41956
41957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41958   void * jresult ;
41959   Dali::Gesture::State arg1 ;
41960   Dali::PinchGesture *result = 0 ;
41961
41962   arg1 = (Dali::Gesture::State)jarg1;
41963   {
41964     try {
41965       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41966     } catch (std::out_of_range& e) {
41967       {
41968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41969       };
41970     } catch (std::exception& e) {
41971       {
41972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41973       };
41974     } catch (Dali::DaliException e) {
41975       {
41976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41977       };
41978     } catch (...) {
41979       {
41980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41981       };
41982     }
41983   }
41984
41985   jresult = (void *)result;
41986   return jresult;
41987 }
41988
41989
41990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41991   void * jresult ;
41992   Dali::PinchGesture *arg1 = 0 ;
41993   Dali::PinchGesture *result = 0 ;
41994
41995   arg1 = (Dali::PinchGesture *)jarg1;
41996   if (!arg1) {
41997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41998     return 0;
41999   }
42000   {
42001     try {
42002       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42003     } catch (std::out_of_range& e) {
42004       {
42005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42006       };
42007     } catch (std::exception& e) {
42008       {
42009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42010       };
42011     } catch (Dali::DaliException e) {
42012       {
42013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42014       };
42015     } catch (...) {
42016       {
42017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42018       };
42019     }
42020   }
42021
42022   jresult = (void *)result;
42023   return jresult;
42024 }
42025
42026
42027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42028   void * jresult ;
42029   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42030   Dali::PinchGesture *arg2 = 0 ;
42031   Dali::PinchGesture *result = 0 ;
42032
42033   arg1 = (Dali::PinchGesture *)jarg1;
42034   arg2 = (Dali::PinchGesture *)jarg2;
42035   if (!arg2) {
42036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42037     return 0;
42038   }
42039   {
42040     try {
42041       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42042     } catch (std::out_of_range& e) {
42043       {
42044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42045       };
42046     } catch (std::exception& e) {
42047       {
42048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42049       };
42050     } catch (Dali::DaliException e) {
42051       {
42052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42053       };
42054     } catch (...) {
42055       {
42056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42057       };
42058     }
42059   }
42060
42061   jresult = (void *)result;
42062   return jresult;
42063 }
42064
42065
42066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42067   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42068
42069   arg1 = (Dali::PinchGesture *)jarg1;
42070   {
42071     try {
42072       delete arg1;
42073     } catch (std::out_of_range& e) {
42074       {
42075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42076       };
42077     } catch (std::exception& e) {
42078       {
42079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42080       };
42081     } catch (Dali::DaliException e) {
42082       {
42083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42084       };
42085     } catch (...) {
42086       {
42087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42088       };
42089     }
42090   }
42091
42092 }
42093
42094
42095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42096   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42097   float arg2 ;
42098
42099   arg1 = (Dali::PinchGesture *)jarg1;
42100   arg2 = (float)jarg2;
42101   if (arg1) (arg1)->scale = arg2;
42102 }
42103
42104
42105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42106   float jresult ;
42107   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42108   float result;
42109
42110   arg1 = (Dali::PinchGesture *)jarg1;
42111   result = (float) ((arg1)->scale);
42112   jresult = result;
42113   return jresult;
42114 }
42115
42116
42117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42118   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42119   float arg2 ;
42120
42121   arg1 = (Dali::PinchGesture *)jarg1;
42122   arg2 = (float)jarg2;
42123   if (arg1) (arg1)->speed = arg2;
42124 }
42125
42126
42127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42128   float jresult ;
42129   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42130   float result;
42131
42132   arg1 = (Dali::PinchGesture *)jarg1;
42133   result = (float) ((arg1)->speed);
42134   jresult = result;
42135   return jresult;
42136 }
42137
42138
42139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42140   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42141   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42142
42143   arg1 = (Dali::PinchGesture *)jarg1;
42144   arg2 = (Dali::Vector2 *)jarg2;
42145   if (arg1) (arg1)->screenCenterPoint = *arg2;
42146 }
42147
42148
42149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42150   void * jresult ;
42151   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42152   Dali::Vector2 *result = 0 ;
42153
42154   arg1 = (Dali::PinchGesture *)jarg1;
42155   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42156   jresult = (void *)result;
42157   return jresult;
42158 }
42159
42160
42161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42162   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42163   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42164
42165   arg1 = (Dali::PinchGesture *)jarg1;
42166   arg2 = (Dali::Vector2 *)jarg2;
42167   if (arg1) (arg1)->localCenterPoint = *arg2;
42168 }
42169
42170
42171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42172   void * jresult ;
42173   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42174   Dali::Vector2 *result = 0 ;
42175
42176   arg1 = (Dali::PinchGesture *)jarg1;
42177   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42178   jresult = (void *)result;
42179   return jresult;
42180 }
42181
42182
42183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42184   void * jresult ;
42185   Dali::TapGestureDetector *result = 0 ;
42186
42187   {
42188     try {
42189       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42190     } catch (std::out_of_range& e) {
42191       {
42192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42193       };
42194     } catch (std::exception& e) {
42195       {
42196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42197       };
42198     } catch (Dali::DaliException e) {
42199       {
42200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42201       };
42202     } catch (...) {
42203       {
42204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42205       };
42206     }
42207   }
42208
42209   jresult = (void *)result;
42210   return jresult;
42211 }
42212
42213
42214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42215   void * jresult ;
42216   Dali::TapGestureDetector result;
42217
42218   {
42219     try {
42220       result = Dali::TapGestureDetector::New();
42221     } catch (std::out_of_range& e) {
42222       {
42223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42224       };
42225     } catch (std::exception& e) {
42226       {
42227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42228       };
42229     } catch (Dali::DaliException e) {
42230       {
42231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42232       };
42233     } catch (...) {
42234       {
42235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42236       };
42237     }
42238   }
42239
42240   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42241   return jresult;
42242 }
42243
42244
42245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42246   void * jresult ;
42247   unsigned int arg1 ;
42248   Dali::TapGestureDetector result;
42249
42250   arg1 = (unsigned int)jarg1;
42251   {
42252     try {
42253       result = Dali::TapGestureDetector::New(arg1);
42254     } catch (std::out_of_range& e) {
42255       {
42256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42257       };
42258     } catch (std::exception& e) {
42259       {
42260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (Dali::DaliException e) {
42263       {
42264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42265       };
42266     } catch (...) {
42267       {
42268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42269       };
42270     }
42271   }
42272
42273   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42274   return jresult;
42275 }
42276
42277
42278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42279   void * jresult ;
42280   Dali::BaseHandle arg1 ;
42281   Dali::BaseHandle *argp1 ;
42282   Dali::TapGestureDetector result;
42283
42284   argp1 = (Dali::BaseHandle *)jarg1;
42285   if (!argp1) {
42286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42287     return 0;
42288   }
42289   arg1 = *argp1;
42290   {
42291     try {
42292       result = Dali::TapGestureDetector::DownCast(arg1);
42293     } catch (std::out_of_range& e) {
42294       {
42295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42296       };
42297     } catch (std::exception& e) {
42298       {
42299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42300       };
42301     } catch (Dali::DaliException e) {
42302       {
42303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42304       };
42305     } catch (...) {
42306       {
42307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42308       };
42309     }
42310   }
42311
42312   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42313   return jresult;
42314 }
42315
42316
42317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42318   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42319
42320   arg1 = (Dali::TapGestureDetector *)jarg1;
42321   {
42322     try {
42323       delete arg1;
42324     } catch (std::out_of_range& e) {
42325       {
42326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42327       };
42328     } catch (std::exception& e) {
42329       {
42330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42331       };
42332     } catch (Dali::DaliException e) {
42333       {
42334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42335       };
42336     } catch (...) {
42337       {
42338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42339       };
42340     }
42341   }
42342
42343 }
42344
42345
42346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42347   void * jresult ;
42348   Dali::TapGestureDetector *arg1 = 0 ;
42349   Dali::TapGestureDetector *result = 0 ;
42350
42351   arg1 = (Dali::TapGestureDetector *)jarg1;
42352   if (!arg1) {
42353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42354     return 0;
42355   }
42356   {
42357     try {
42358       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42359     } catch (std::out_of_range& e) {
42360       {
42361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42362       };
42363     } catch (std::exception& e) {
42364       {
42365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42366       };
42367     } catch (Dali::DaliException e) {
42368       {
42369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42370       };
42371     } catch (...) {
42372       {
42373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42374       };
42375     }
42376   }
42377
42378   jresult = (void *)result;
42379   return jresult;
42380 }
42381
42382
42383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42384   void * jresult ;
42385   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42386   Dali::TapGestureDetector *arg2 = 0 ;
42387   Dali::TapGestureDetector *result = 0 ;
42388
42389   arg1 = (Dali::TapGestureDetector *)jarg1;
42390   arg2 = (Dali::TapGestureDetector *)jarg2;
42391   if (!arg2) {
42392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42393     return 0;
42394   }
42395   {
42396     try {
42397       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42398     } catch (std::out_of_range& e) {
42399       {
42400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42401       };
42402     } catch (std::exception& e) {
42403       {
42404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42405       };
42406     } catch (Dali::DaliException e) {
42407       {
42408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42409       };
42410     } catch (...) {
42411       {
42412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42413       };
42414     }
42415   }
42416
42417   jresult = (void *)result;
42418   return jresult;
42419 }
42420
42421
42422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42423   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42424   unsigned int arg2 ;
42425
42426   arg1 = (Dali::TapGestureDetector *)jarg1;
42427   arg2 = (unsigned int)jarg2;
42428   {
42429     try {
42430       (arg1)->SetMinimumTapsRequired(arg2);
42431     } catch (std::out_of_range& e) {
42432       {
42433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42434       };
42435     } catch (std::exception& e) {
42436       {
42437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42438       };
42439     } catch (Dali::DaliException e) {
42440       {
42441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42442       };
42443     } catch (...) {
42444       {
42445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42446       };
42447     }
42448   }
42449
42450 }
42451
42452
42453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42454   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42455   unsigned int arg2 ;
42456
42457   arg1 = (Dali::TapGestureDetector *)jarg1;
42458   arg2 = (unsigned int)jarg2;
42459   {
42460     try {
42461       (arg1)->SetMaximumTapsRequired(arg2);
42462     } catch (std::out_of_range& e) {
42463       {
42464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42465       };
42466     } catch (std::exception& e) {
42467       {
42468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42469       };
42470     } catch (Dali::DaliException e) {
42471       {
42472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42473       };
42474     } catch (...) {
42475       {
42476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42477       };
42478     }
42479   }
42480
42481 }
42482
42483
42484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42485   unsigned int jresult ;
42486   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42487   unsigned int result;
42488
42489   arg1 = (Dali::TapGestureDetector *)jarg1;
42490   {
42491     try {
42492       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42493     } catch (std::out_of_range& e) {
42494       {
42495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42496       };
42497     } catch (std::exception& e) {
42498       {
42499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42500       };
42501     } catch (Dali::DaliException e) {
42502       {
42503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42504       };
42505     } catch (...) {
42506       {
42507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42508       };
42509     }
42510   }
42511
42512   jresult = result;
42513   return jresult;
42514 }
42515
42516
42517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42518   unsigned int jresult ;
42519   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42520   unsigned int result;
42521
42522   arg1 = (Dali::TapGestureDetector *)jarg1;
42523   {
42524     try {
42525       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42526     } catch (std::out_of_range& e) {
42527       {
42528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42529       };
42530     } catch (std::exception& e) {
42531       {
42532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42533       };
42534     } catch (Dali::DaliException e) {
42535       {
42536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42537       };
42538     } catch (...) {
42539       {
42540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42541       };
42542     }
42543   }
42544
42545   jresult = result;
42546   return jresult;
42547 }
42548
42549
42550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42551   void * jresult ;
42552   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42553   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42554
42555   arg1 = (Dali::TapGestureDetector *)jarg1;
42556   {
42557     try {
42558       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42559     } catch (std::out_of_range& e) {
42560       {
42561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42562       };
42563     } catch (std::exception& e) {
42564       {
42565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42566       };
42567     } catch (Dali::DaliException e) {
42568       {
42569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42570       };
42571     } catch (...) {
42572       {
42573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42574       };
42575     }
42576   }
42577
42578   jresult = (void *)result;
42579   return jresult;
42580 }
42581
42582
42583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42584   void * jresult ;
42585   Dali::TapGesture *result = 0 ;
42586
42587   {
42588     try {
42589       result = (Dali::TapGesture *)new Dali::TapGesture();
42590     } catch (std::out_of_range& e) {
42591       {
42592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42593       };
42594     } catch (std::exception& e) {
42595       {
42596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42597       };
42598     } catch (Dali::DaliException e) {
42599       {
42600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42601       };
42602     } catch (...) {
42603       {
42604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42605       };
42606     }
42607   }
42608
42609   jresult = (void *)result;
42610   return jresult;
42611 }
42612
42613
42614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42615   void * jresult ;
42616   Dali::TapGesture *arg1 = 0 ;
42617   Dali::TapGesture *result = 0 ;
42618
42619   arg1 = (Dali::TapGesture *)jarg1;
42620   if (!arg1) {
42621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42622     return 0;
42623   }
42624   {
42625     try {
42626       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42627     } catch (std::out_of_range& e) {
42628       {
42629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42630       };
42631     } catch (std::exception& e) {
42632       {
42633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42634       };
42635     } catch (Dali::DaliException e) {
42636       {
42637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42638       };
42639     } catch (...) {
42640       {
42641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42642       };
42643     }
42644   }
42645
42646   jresult = (void *)result;
42647   return jresult;
42648 }
42649
42650
42651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42652   void * jresult ;
42653   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42654   Dali::TapGesture *arg2 = 0 ;
42655   Dali::TapGesture *result = 0 ;
42656
42657   arg1 = (Dali::TapGesture *)jarg1;
42658   arg2 = (Dali::TapGesture *)jarg2;
42659   if (!arg2) {
42660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42661     return 0;
42662   }
42663   {
42664     try {
42665       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42666     } catch (std::out_of_range& e) {
42667       {
42668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42669       };
42670     } catch (std::exception& e) {
42671       {
42672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42673       };
42674     } catch (Dali::DaliException e) {
42675       {
42676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42677       };
42678     } catch (...) {
42679       {
42680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42681       };
42682     }
42683   }
42684
42685   jresult = (void *)result;
42686   return jresult;
42687 }
42688
42689
42690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42691   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42692
42693   arg1 = (Dali::TapGesture *)jarg1;
42694   {
42695     try {
42696       delete arg1;
42697     } catch (std::out_of_range& e) {
42698       {
42699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42700       };
42701     } catch (std::exception& e) {
42702       {
42703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42704       };
42705     } catch (Dali::DaliException e) {
42706       {
42707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42708       };
42709     } catch (...) {
42710       {
42711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42712       };
42713     }
42714   }
42715
42716 }
42717
42718
42719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42720   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42721   unsigned int arg2 ;
42722
42723   arg1 = (Dali::TapGesture *)jarg1;
42724   arg2 = (unsigned int)jarg2;
42725   if (arg1) (arg1)->numberOfTaps = arg2;
42726 }
42727
42728
42729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42730   unsigned int jresult ;
42731   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42732   unsigned int result;
42733
42734   arg1 = (Dali::TapGesture *)jarg1;
42735   result = (unsigned int) ((arg1)->numberOfTaps);
42736   jresult = result;
42737   return jresult;
42738 }
42739
42740
42741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42742   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42743   unsigned int arg2 ;
42744
42745   arg1 = (Dali::TapGesture *)jarg1;
42746   arg2 = (unsigned int)jarg2;
42747   if (arg1) (arg1)->numberOfTouches = arg2;
42748 }
42749
42750
42751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42752   unsigned int jresult ;
42753   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42754   unsigned int result;
42755
42756   arg1 = (Dali::TapGesture *)jarg1;
42757   result = (unsigned int) ((arg1)->numberOfTouches);
42758   jresult = result;
42759   return jresult;
42760 }
42761
42762
42763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42764   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42765   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42766
42767   arg1 = (Dali::TapGesture *)jarg1;
42768   arg2 = (Dali::Vector2 *)jarg2;
42769   if (arg1) (arg1)->screenPoint = *arg2;
42770 }
42771
42772
42773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42774   void * jresult ;
42775   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42776   Dali::Vector2 *result = 0 ;
42777
42778   arg1 = (Dali::TapGesture *)jarg1;
42779   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42780   jresult = (void *)result;
42781   return jresult;
42782 }
42783
42784
42785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42786   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42787   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42788
42789   arg1 = (Dali::TapGesture *)jarg1;
42790   arg2 = (Dali::Vector2 *)jarg2;
42791   if (arg1) (arg1)->localPoint = *arg2;
42792 }
42793
42794
42795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42796   void * jresult ;
42797   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42798   Dali::Vector2 *result = 0 ;
42799
42800   arg1 = (Dali::TapGesture *)jarg1;
42801   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42802   jresult = (void *)result;
42803   return jresult;
42804 }
42805
42806
42807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42808   void * jresult ;
42809   Dali::AlphaFunction *result = 0 ;
42810
42811   {
42812     try {
42813       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42814     } catch (std::out_of_range& e) {
42815       {
42816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42817       };
42818     } catch (std::exception& e) {
42819       {
42820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42821       };
42822     } catch (Dali::DaliException e) {
42823       {
42824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42825       };
42826     } catch (...) {
42827       {
42828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42829       };
42830     }
42831   }
42832
42833   jresult = (void *)result;
42834   return jresult;
42835 }
42836
42837
42838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42839   void * jresult ;
42840   Dali::AlphaFunction::BuiltinFunction arg1 ;
42841   Dali::AlphaFunction *result = 0 ;
42842
42843   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42844   {
42845     try {
42846       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42847     } catch (std::out_of_range& e) {
42848       {
42849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42850       };
42851     } catch (std::exception& e) {
42852       {
42853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42854       };
42855     } catch (Dali::DaliException e) {
42856       {
42857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42858       };
42859     } catch (...) {
42860       {
42861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42862       };
42863     }
42864   }
42865
42866   jresult = (void *)result;
42867   return jresult;
42868 }
42869
42870
42871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42872   void * jresult ;
42873   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42874   Dali::AlphaFunction *result = 0 ;
42875
42876   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42877   {
42878     try {
42879       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42880     } catch (std::out_of_range& e) {
42881       {
42882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42883       };
42884     } catch (std::exception& e) {
42885       {
42886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42887       };
42888     } catch (Dali::DaliException e) {
42889       {
42890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42891       };
42892     } catch (...) {
42893       {
42894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42895       };
42896     }
42897   }
42898
42899   jresult = (void *)result;
42900   return jresult;
42901 }
42902
42903
42904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42905   void * jresult ;
42906   Dali::Vector2 *arg1 = 0 ;
42907   Dali::Vector2 *arg2 = 0 ;
42908   Dali::AlphaFunction *result = 0 ;
42909
42910   arg1 = (Dali::Vector2 *)jarg1;
42911   if (!arg1) {
42912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42913     return 0;
42914   }
42915   arg2 = (Dali::Vector2 *)jarg2;
42916   if (!arg2) {
42917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42918     return 0;
42919   }
42920   {
42921     try {
42922       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42923     } catch (std::out_of_range& e) {
42924       {
42925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42926       };
42927     } catch (std::exception& e) {
42928       {
42929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42930       };
42931     } catch (Dali::DaliException e) {
42932       {
42933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42934       };
42935     } catch (...) {
42936       {
42937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42938       };
42939     }
42940   }
42941
42942   jresult = (void *)result;
42943   return jresult;
42944 }
42945
42946
42947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42948   void * jresult ;
42949   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42950   Dali::Vector4 result;
42951
42952   arg1 = (Dali::AlphaFunction *)jarg1;
42953   {
42954     try {
42955       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42956     } catch (std::out_of_range& e) {
42957       {
42958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42959       };
42960     } catch (std::exception& e) {
42961       {
42962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42963       };
42964     } catch (Dali::DaliException e) {
42965       {
42966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42967       };
42968     } catch (...) {
42969       {
42970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42971       };
42972     }
42973   }
42974
42975   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42976   return jresult;
42977 }
42978
42979
42980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42981   void * jresult ;
42982   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42983   Dali::AlphaFunctionPrototype result;
42984
42985   arg1 = (Dali::AlphaFunction *)jarg1;
42986   {
42987     try {
42988       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42989     } catch (std::out_of_range& e) {
42990       {
42991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42992       };
42993     } catch (std::exception& e) {
42994       {
42995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42996       };
42997     } catch (Dali::DaliException e) {
42998       {
42999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43000       };
43001     } catch (...) {
43002       {
43003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43004       };
43005     }
43006   }
43007
43008   jresult = (void *)result;
43009   return jresult;
43010 }
43011
43012
43013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43014   int jresult ;
43015   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43016   Dali::AlphaFunction::BuiltinFunction result;
43017
43018   arg1 = (Dali::AlphaFunction *)jarg1;
43019   {
43020     try {
43021       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43022     } catch (std::out_of_range& e) {
43023       {
43024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43025       };
43026     } catch (std::exception& e) {
43027       {
43028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43029       };
43030     } catch (Dali::DaliException e) {
43031       {
43032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43033       };
43034     } catch (...) {
43035       {
43036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43037       };
43038     }
43039   }
43040
43041   jresult = (int)result;
43042   return jresult;
43043 }
43044
43045
43046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43047   int jresult ;
43048   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43049   Dali::AlphaFunction::Mode result;
43050
43051   arg1 = (Dali::AlphaFunction *)jarg1;
43052   {
43053     try {
43054       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43055     } catch (std::out_of_range& e) {
43056       {
43057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43058       };
43059     } catch (std::exception& e) {
43060       {
43061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43062       };
43063     } catch (Dali::DaliException e) {
43064       {
43065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43066       };
43067     } catch (...) {
43068       {
43069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43070       };
43071     }
43072   }
43073
43074   jresult = (int)result;
43075   return jresult;
43076 }
43077
43078
43079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43080   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43081
43082   arg1 = (Dali::AlphaFunction *)jarg1;
43083   {
43084     try {
43085       delete arg1;
43086     } catch (std::out_of_range& e) {
43087       {
43088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43089       };
43090     } catch (std::exception& e) {
43091       {
43092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43093       };
43094     } catch (Dali::DaliException e) {
43095       {
43096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43097       };
43098     } catch (...) {
43099       {
43100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43101       };
43102     }
43103   }
43104
43105 }
43106
43107
43108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43109   void * jresult ;
43110   Dali::KeyFrames result;
43111
43112   {
43113     try {
43114       result = Dali::KeyFrames::New();
43115     } catch (std::out_of_range& e) {
43116       {
43117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43118       };
43119     } catch (std::exception& e) {
43120       {
43121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43122       };
43123     } catch (Dali::DaliException e) {
43124       {
43125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43126       };
43127     } catch (...) {
43128       {
43129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43130       };
43131     }
43132   }
43133
43134   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43135   return jresult;
43136 }
43137
43138
43139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43140   void * jresult ;
43141   Dali::BaseHandle arg1 ;
43142   Dali::BaseHandle *argp1 ;
43143   Dali::KeyFrames result;
43144
43145   argp1 = (Dali::BaseHandle *)jarg1;
43146   if (!argp1) {
43147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43148     return 0;
43149   }
43150   arg1 = *argp1;
43151   {
43152     try {
43153       result = Dali::KeyFrames::DownCast(arg1);
43154     } catch (std::out_of_range& e) {
43155       {
43156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43157       };
43158     } catch (std::exception& e) {
43159       {
43160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43161       };
43162     } catch (Dali::DaliException e) {
43163       {
43164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43165       };
43166     } catch (...) {
43167       {
43168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43169       };
43170     }
43171   }
43172
43173   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43174   return jresult;
43175 }
43176
43177
43178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43179   void * jresult ;
43180   Dali::KeyFrames *result = 0 ;
43181
43182   {
43183     try {
43184       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43185     } catch (std::out_of_range& e) {
43186       {
43187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43188       };
43189     } catch (std::exception& e) {
43190       {
43191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43192       };
43193     } catch (Dali::DaliException e) {
43194       {
43195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43196       };
43197     } catch (...) {
43198       {
43199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43200       };
43201     }
43202   }
43203
43204   jresult = (void *)result;
43205   return jresult;
43206 }
43207
43208
43209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43210   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43211
43212   arg1 = (Dali::KeyFrames *)jarg1;
43213   {
43214     try {
43215       delete arg1;
43216     } catch (std::out_of_range& e) {
43217       {
43218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43219       };
43220     } catch (std::exception& e) {
43221       {
43222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43223       };
43224     } catch (Dali::DaliException e) {
43225       {
43226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43227       };
43228     } catch (...) {
43229       {
43230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43231       };
43232     }
43233   }
43234
43235 }
43236
43237
43238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43239   void * jresult ;
43240   Dali::KeyFrames *arg1 = 0 ;
43241   Dali::KeyFrames *result = 0 ;
43242
43243   arg1 = (Dali::KeyFrames *)jarg1;
43244   if (!arg1) {
43245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43246     return 0;
43247   }
43248   {
43249     try {
43250       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43251     } catch (std::out_of_range& e) {
43252       {
43253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43254       };
43255     } catch (std::exception& e) {
43256       {
43257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43258       };
43259     } catch (Dali::DaliException e) {
43260       {
43261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43262       };
43263     } catch (...) {
43264       {
43265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43266       };
43267     }
43268   }
43269
43270   jresult = (void *)result;
43271   return jresult;
43272 }
43273
43274
43275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43276   void * jresult ;
43277   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43278   Dali::KeyFrames *arg2 = 0 ;
43279   Dali::KeyFrames *result = 0 ;
43280
43281   arg1 = (Dali::KeyFrames *)jarg1;
43282   arg2 = (Dali::KeyFrames *)jarg2;
43283   if (!arg2) {
43284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43285     return 0;
43286   }
43287   {
43288     try {
43289       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43290     } catch (std::out_of_range& e) {
43291       {
43292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43293       };
43294     } catch (std::exception& e) {
43295       {
43296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43297       };
43298     } catch (Dali::DaliException e) {
43299       {
43300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43301       };
43302     } catch (...) {
43303       {
43304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43305       };
43306     }
43307   }
43308
43309   jresult = (void *)result;
43310   return jresult;
43311 }
43312
43313
43314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43315   int jresult ;
43316   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43317   Dali::Property::Type result;
43318
43319   arg1 = (Dali::KeyFrames *)jarg1;
43320   {
43321     try {
43322       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43323     } catch (std::out_of_range& e) {
43324       {
43325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43326       };
43327     } catch (std::exception& e) {
43328       {
43329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43330       };
43331     } catch (Dali::DaliException e) {
43332       {
43333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43334       };
43335     } catch (...) {
43336       {
43337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43338       };
43339     }
43340   }
43341
43342   jresult = (int)result;
43343   return jresult;
43344 }
43345
43346
43347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43348   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43349   float arg2 ;
43350   Dali::Property::Value arg3 ;
43351   Dali::Property::Value *argp3 ;
43352
43353   arg1 = (Dali::KeyFrames *)jarg1;
43354   arg2 = (float)jarg2;
43355   argp3 = (Dali::Property::Value *)jarg3;
43356   if (!argp3) {
43357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43358     return ;
43359   }
43360   arg3 = *argp3;
43361   {
43362     try {
43363       (arg1)->Add(arg2,arg3);
43364     } catch (std::out_of_range& e) {
43365       {
43366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43367       };
43368     } catch (std::exception& e) {
43369       {
43370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43371       };
43372     } catch (Dali::DaliException e) {
43373       {
43374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43375       };
43376     } catch (...) {
43377       {
43378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43379       };
43380     }
43381   }
43382
43383 }
43384
43385
43386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43387   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43388   float arg2 ;
43389   Dali::Property::Value arg3 ;
43390   Dali::AlphaFunction arg4 ;
43391   Dali::Property::Value *argp3 ;
43392   Dali::AlphaFunction *argp4 ;
43393
43394   arg1 = (Dali::KeyFrames *)jarg1;
43395   arg2 = (float)jarg2;
43396   argp3 = (Dali::Property::Value *)jarg3;
43397   if (!argp3) {
43398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43399     return ;
43400   }
43401   arg3 = *argp3;
43402   argp4 = (Dali::AlphaFunction *)jarg4;
43403   if (!argp4) {
43404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43405     return ;
43406   }
43407   arg4 = *argp4;
43408   {
43409     try {
43410       (arg1)->Add(arg2,arg3,arg4);
43411     } catch (std::out_of_range& e) {
43412       {
43413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43414       };
43415     } catch (std::exception& e) {
43416       {
43417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43418       };
43419     } catch (Dali::DaliException e) {
43420       {
43421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43422       };
43423     } catch (...) {
43424       {
43425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43426       };
43427     }
43428   }
43429
43430 }
43431
43432
43433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43434   int jresult ;
43435   int result;
43436
43437   result = (int)Dali::Path::Property::POINTS;
43438   jresult = (int)result;
43439   return jresult;
43440 }
43441
43442
43443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43444   int jresult ;
43445   int result;
43446
43447   result = (int)Dali::Path::Property::CONTROL_POINTS;
43448   jresult = (int)result;
43449   return jresult;
43450 }
43451
43452
43453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43454   void * jresult ;
43455   Dali::Path::Property *result = 0 ;
43456
43457   {
43458     try {
43459       result = (Dali::Path::Property *)new Dali::Path::Property();
43460     } catch (std::out_of_range& e) {
43461       {
43462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43463       };
43464     } catch (std::exception& e) {
43465       {
43466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43467       };
43468     } catch (Dali::DaliException e) {
43469       {
43470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43471       };
43472     } catch (...) {
43473       {
43474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43475       };
43476     }
43477   }
43478
43479   jresult = (void *)result;
43480   return jresult;
43481 }
43482
43483
43484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43485   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43486
43487   arg1 = (Dali::Path::Property *)jarg1;
43488   {
43489     try {
43490       delete arg1;
43491     } catch (std::out_of_range& e) {
43492       {
43493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43494       };
43495     } catch (std::exception& e) {
43496       {
43497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43498       };
43499     } catch (Dali::DaliException e) {
43500       {
43501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43502       };
43503     } catch (...) {
43504       {
43505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43506       };
43507     }
43508   }
43509
43510 }
43511
43512
43513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43514   void * jresult ;
43515   Dali::Path result;
43516
43517   {
43518     try {
43519       result = Dali::Path::New();
43520     } catch (std::out_of_range& e) {
43521       {
43522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43523       };
43524     } catch (std::exception& e) {
43525       {
43526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43527       };
43528     } catch (Dali::DaliException e) {
43529       {
43530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43531       };
43532     } catch (...) {
43533       {
43534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43535       };
43536     }
43537   }
43538
43539   jresult = new Dali::Path((const Dali::Path &)result);
43540   return jresult;
43541 }
43542
43543
43544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43545   void * jresult ;
43546   Dali::BaseHandle arg1 ;
43547   Dali::BaseHandle *argp1 ;
43548   Dali::Path result;
43549
43550   argp1 = (Dali::BaseHandle *)jarg1;
43551   if (!argp1) {
43552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43553     return 0;
43554   }
43555   arg1 = *argp1;
43556   {
43557     try {
43558       result = Dali::Path::DownCast(arg1);
43559     } catch (std::out_of_range& e) {
43560       {
43561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43562       };
43563     } catch (std::exception& e) {
43564       {
43565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43566       };
43567     } catch (Dali::DaliException e) {
43568       {
43569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43570       };
43571     } catch (...) {
43572       {
43573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43574       };
43575     }
43576   }
43577
43578   jresult = new Dali::Path((const Dali::Path &)result);
43579   return jresult;
43580 }
43581
43582
43583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43584   void * jresult ;
43585   Dali::Path *result = 0 ;
43586
43587   {
43588     try {
43589       result = (Dali::Path *)new Dali::Path();
43590     } catch (std::out_of_range& e) {
43591       {
43592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43593       };
43594     } catch (std::exception& e) {
43595       {
43596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (Dali::DaliException e) {
43599       {
43600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43601       };
43602     } catch (...) {
43603       {
43604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43605       };
43606     }
43607   }
43608
43609   jresult = (void *)result;
43610   return jresult;
43611 }
43612
43613
43614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43615   Dali::Path *arg1 = (Dali::Path *) 0 ;
43616
43617   arg1 = (Dali::Path *)jarg1;
43618   {
43619     try {
43620       delete arg1;
43621     } catch (std::out_of_range& e) {
43622       {
43623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43624       };
43625     } catch (std::exception& e) {
43626       {
43627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43628       };
43629     } catch (Dali::DaliException e) {
43630       {
43631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43632       };
43633     } catch (...) {
43634       {
43635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43636       };
43637     }
43638   }
43639
43640 }
43641
43642
43643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43644   void * jresult ;
43645   Dali::Path *arg1 = 0 ;
43646   Dali::Path *result = 0 ;
43647
43648   arg1 = (Dali::Path *)jarg1;
43649   if (!arg1) {
43650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43651     return 0;
43652   }
43653   {
43654     try {
43655       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43656     } catch (std::out_of_range& e) {
43657       {
43658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43659       };
43660     } catch (std::exception& e) {
43661       {
43662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (Dali::DaliException e) {
43665       {
43666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43667       };
43668     } catch (...) {
43669       {
43670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43671       };
43672     }
43673   }
43674
43675   jresult = (void *)result;
43676   return jresult;
43677 }
43678
43679
43680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43681   void * jresult ;
43682   Dali::Path *arg1 = (Dali::Path *) 0 ;
43683   Dali::Path *arg2 = 0 ;
43684   Dali::Path *result = 0 ;
43685
43686   arg1 = (Dali::Path *)jarg1;
43687   arg2 = (Dali::Path *)jarg2;
43688   if (!arg2) {
43689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43690     return 0;
43691   }
43692   {
43693     try {
43694       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43695     } catch (std::out_of_range& e) {
43696       {
43697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43698       };
43699     } catch (std::exception& e) {
43700       {
43701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43702       };
43703     } catch (Dali::DaliException e) {
43704       {
43705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43706       };
43707     } catch (...) {
43708       {
43709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43710       };
43711     }
43712   }
43713
43714   jresult = (void *)result;
43715   return jresult;
43716 }
43717
43718
43719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43720   Dali::Path *arg1 = (Dali::Path *) 0 ;
43721   Dali::Vector3 *arg2 = 0 ;
43722
43723   arg1 = (Dali::Path *)jarg1;
43724   arg2 = (Dali::Vector3 *)jarg2;
43725   if (!arg2) {
43726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43727     return ;
43728   }
43729   {
43730     try {
43731       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43732     } catch (std::out_of_range& e) {
43733       {
43734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43735       };
43736     } catch (std::exception& e) {
43737       {
43738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43739       };
43740     } catch (Dali::DaliException e) {
43741       {
43742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43743       };
43744     } catch (...) {
43745       {
43746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43747       };
43748     }
43749   }
43750
43751 }
43752
43753
43754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43755   Dali::Path *arg1 = (Dali::Path *) 0 ;
43756   Dali::Vector3 *arg2 = 0 ;
43757
43758   arg1 = (Dali::Path *)jarg1;
43759   arg2 = (Dali::Vector3 *)jarg2;
43760   if (!arg2) {
43761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43762     return ;
43763   }
43764   {
43765     try {
43766       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43767     } catch (std::out_of_range& e) {
43768       {
43769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43770       };
43771     } catch (std::exception& e) {
43772       {
43773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43774       };
43775     } catch (Dali::DaliException e) {
43776       {
43777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43778       };
43779     } catch (...) {
43780       {
43781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43782       };
43783     }
43784   }
43785
43786 }
43787
43788
43789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43790   Dali::Path *arg1 = (Dali::Path *) 0 ;
43791   float arg2 ;
43792
43793   arg1 = (Dali::Path *)jarg1;
43794   arg2 = (float)jarg2;
43795   {
43796     try {
43797       (arg1)->GenerateControlPoints(arg2);
43798     } catch (std::out_of_range& e) {
43799       {
43800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43801       };
43802     } catch (std::exception& e) {
43803       {
43804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43805       };
43806     } catch (Dali::DaliException e) {
43807       {
43808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43809       };
43810     } catch (...) {
43811       {
43812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43813       };
43814     }
43815   }
43816
43817 }
43818
43819
43820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43821   Dali::Path *arg1 = (Dali::Path *) 0 ;
43822   float arg2 ;
43823   Dali::Vector3 *arg3 = 0 ;
43824   Dali::Vector3 *arg4 = 0 ;
43825
43826   arg1 = (Dali::Path *)jarg1;
43827   arg2 = (float)jarg2;
43828   arg3 = (Dali::Vector3 *)jarg3;
43829   if (!arg3) {
43830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43831     return ;
43832   }
43833   arg4 = (Dali::Vector3 *)jarg4;
43834   if (!arg4) {
43835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43836     return ;
43837   }
43838   {
43839     try {
43840       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43841     } catch (std::out_of_range& e) {
43842       {
43843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43844       };
43845     } catch (std::exception& e) {
43846       {
43847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43848       };
43849     } catch (Dali::DaliException e) {
43850       {
43851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43852       };
43853     } catch (...) {
43854       {
43855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43856       };
43857     }
43858   }
43859
43860 }
43861
43862
43863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43864   void * jresult ;
43865   Dali::Path *arg1 = (Dali::Path *) 0 ;
43866   size_t arg2 ;
43867   Dali::Vector3 *result = 0 ;
43868
43869   arg1 = (Dali::Path *)jarg1;
43870   arg2 = (size_t)jarg2;
43871   {
43872     try {
43873       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43874     } catch (std::out_of_range& e) {
43875       {
43876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43877       };
43878     } catch (std::exception& e) {
43879       {
43880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43881       };
43882     } catch (Dali::DaliException e) {
43883       {
43884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43885       };
43886     } catch (...) {
43887       {
43888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43889       };
43890     }
43891   }
43892
43893   jresult = (void *)result;
43894   return jresult;
43895 }
43896
43897
43898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43899   void * jresult ;
43900   Dali::Path *arg1 = (Dali::Path *) 0 ;
43901   size_t arg2 ;
43902   Dali::Vector3 *result = 0 ;
43903
43904   arg1 = (Dali::Path *)jarg1;
43905   arg2 = (size_t)jarg2;
43906   {
43907     try {
43908       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43909     } catch (std::out_of_range& e) {
43910       {
43911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43912       };
43913     } catch (std::exception& e) {
43914       {
43915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43916       };
43917     } catch (Dali::DaliException e) {
43918       {
43919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43920       };
43921     } catch (...) {
43922       {
43923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43924       };
43925     }
43926   }
43927
43928   jresult = (void *)result;
43929   return jresult;
43930 }
43931
43932
43933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43934   unsigned long jresult ;
43935   Dali::Path *arg1 = (Dali::Path *) 0 ;
43936   size_t result;
43937
43938   arg1 = (Dali::Path *)jarg1;
43939   {
43940     try {
43941       result = ((Dali::Path const *)arg1)->GetPointCount();
43942     } catch (std::out_of_range& e) {
43943       {
43944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43945       };
43946     } catch (std::exception& e) {
43947       {
43948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43949       };
43950     } catch (Dali::DaliException e) {
43951       {
43952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43953       };
43954     } catch (...) {
43955       {
43956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43957       };
43958     }
43959   }
43960
43961   jresult = (unsigned long)result;
43962   return jresult;
43963 }
43964
43965
43966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43967   void * jresult ;
43968   float arg1 ;
43969   Dali::TimePeriod *result = 0 ;
43970
43971   arg1 = (float)jarg1;
43972   {
43973     try {
43974       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43975     } catch (std::out_of_range& e) {
43976       {
43977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43978       };
43979     } catch (std::exception& e) {
43980       {
43981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43982       };
43983     } catch (Dali::DaliException e) {
43984       {
43985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43986       };
43987     } catch (...) {
43988       {
43989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43990       };
43991     }
43992   }
43993
43994   jresult = (void *)result;
43995   return jresult;
43996 }
43997
43998
43999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44000   void * jresult ;
44001   float arg1 ;
44002   float arg2 ;
44003   Dali::TimePeriod *result = 0 ;
44004
44005   arg1 = (float)jarg1;
44006   arg2 = (float)jarg2;
44007   {
44008     try {
44009       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44010     } catch (std::out_of_range& e) {
44011       {
44012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44013       };
44014     } catch (std::exception& e) {
44015       {
44016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44017       };
44018     } catch (Dali::DaliException e) {
44019       {
44020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44021       };
44022     } catch (...) {
44023       {
44024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44025       };
44026     }
44027   }
44028
44029   jresult = (void *)result;
44030   return jresult;
44031 }
44032
44033
44034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44035   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44036
44037   arg1 = (Dali::TimePeriod *)jarg1;
44038   {
44039     try {
44040       delete arg1;
44041     } catch (std::out_of_range& e) {
44042       {
44043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44044       };
44045     } catch (std::exception& e) {
44046       {
44047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44048       };
44049     } catch (Dali::DaliException e) {
44050       {
44051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44052       };
44053     } catch (...) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44056       };
44057     }
44058   }
44059
44060 }
44061
44062
44063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44064   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44065   float arg2 ;
44066
44067   arg1 = (Dali::TimePeriod *)jarg1;
44068   arg2 = (float)jarg2;
44069   if (arg1) (arg1)->delaySeconds = arg2;
44070 }
44071
44072
44073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44074   float jresult ;
44075   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44076   float result;
44077
44078   arg1 = (Dali::TimePeriod *)jarg1;
44079   result = (float) ((arg1)->delaySeconds);
44080   jresult = result;
44081   return jresult;
44082 }
44083
44084
44085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44086   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44087   float arg2 ;
44088
44089   arg1 = (Dali::TimePeriod *)jarg1;
44090   arg2 = (float)jarg2;
44091   if (arg1) (arg1)->durationSeconds = arg2;
44092 }
44093
44094
44095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44096   float jresult ;
44097   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44098   float result;
44099
44100   arg1 = (Dali::TimePeriod *)jarg1;
44101   result = (float) ((arg1)->durationSeconds);
44102   jresult = result;
44103   return jresult;
44104 }
44105
44106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44107   int jresult ;
44108   int result;
44109
44110   result = (int)Dali::LinearConstrainer::Property::VALUE;
44111   jresult = (int)result;
44112   return jresult;
44113 }
44114
44115
44116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44117   int jresult ;
44118   int result;
44119
44120   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44121   jresult = (int)result;
44122   return jresult;
44123 }
44124
44125
44126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44127   void * jresult ;
44128   Dali::LinearConstrainer::Property *result = 0 ;
44129
44130   {
44131     try {
44132       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44133     } catch (std::out_of_range& e) {
44134       {
44135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44136       };
44137     } catch (std::exception& e) {
44138       {
44139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44140       };
44141     } catch (Dali::DaliException e) {
44142       {
44143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44148       };
44149     }
44150   }
44151
44152   jresult = (void *)result;
44153   return jresult;
44154 }
44155
44156
44157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44158   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44159
44160   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44161   {
44162     try {
44163       delete arg1;
44164     } catch (std::out_of_range& e) {
44165       {
44166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44167       };
44168     } catch (std::exception& e) {
44169       {
44170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44171       };
44172     } catch (Dali::DaliException e) {
44173       {
44174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44175       };
44176     } catch (...) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44179       };
44180     }
44181   }
44182
44183 }
44184
44185
44186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44187   void * jresult ;
44188   Dali::LinearConstrainer result;
44189
44190   {
44191     try {
44192       result = Dali::LinearConstrainer::New();
44193     } catch (std::out_of_range& e) {
44194       {
44195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44196       };
44197     } catch (std::exception& e) {
44198       {
44199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44200       };
44201     } catch (Dali::DaliException e) {
44202       {
44203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44204       };
44205     } catch (...) {
44206       {
44207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44208       };
44209     }
44210   }
44211
44212   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44213   return jresult;
44214 }
44215
44216
44217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44218   void * jresult ;
44219   Dali::BaseHandle arg1 ;
44220   Dali::BaseHandle *argp1 ;
44221   Dali::LinearConstrainer result;
44222
44223   argp1 = (Dali::BaseHandle *)jarg1;
44224   if (!argp1) {
44225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44226     return 0;
44227   }
44228   arg1 = *argp1;
44229   {
44230     try {
44231       result = Dali::LinearConstrainer::DownCast(arg1);
44232     } catch (std::out_of_range& e) {
44233       {
44234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44235       };
44236     } catch (std::exception& e) {
44237       {
44238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44239       };
44240     } catch (Dali::DaliException e) {
44241       {
44242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44243       };
44244     } catch (...) {
44245       {
44246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44247       };
44248     }
44249   }
44250
44251   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44252   return jresult;
44253 }
44254
44255
44256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44257   void * jresult ;
44258   Dali::LinearConstrainer *result = 0 ;
44259
44260   {
44261     try {
44262       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44263     } catch (std::out_of_range& e) {
44264       {
44265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44266       };
44267     } catch (std::exception& e) {
44268       {
44269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44270       };
44271     } catch (Dali::DaliException e) {
44272       {
44273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44274       };
44275     } catch (...) {
44276       {
44277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44278       };
44279     }
44280   }
44281
44282   jresult = (void *)result;
44283   return jresult;
44284 }
44285
44286
44287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44288   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44289
44290   arg1 = (Dali::LinearConstrainer *)jarg1;
44291   {
44292     try {
44293       delete arg1;
44294     } catch (std::out_of_range& e) {
44295       {
44296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44297       };
44298     } catch (std::exception& e) {
44299       {
44300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44301       };
44302     } catch (Dali::DaliException e) {
44303       {
44304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44305       };
44306     } catch (...) {
44307       {
44308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44309       };
44310     }
44311   }
44312
44313 }
44314
44315
44316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44317   void * jresult ;
44318   Dali::LinearConstrainer *arg1 = 0 ;
44319   Dali::LinearConstrainer *result = 0 ;
44320
44321   arg1 = (Dali::LinearConstrainer *)jarg1;
44322   if (!arg1) {
44323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44324     return 0;
44325   }
44326   {
44327     try {
44328       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44329     } catch (std::out_of_range& e) {
44330       {
44331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44332       };
44333     } catch (std::exception& e) {
44334       {
44335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44336       };
44337     } catch (Dali::DaliException e) {
44338       {
44339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44340       };
44341     } catch (...) {
44342       {
44343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44344       };
44345     }
44346   }
44347
44348   jresult = (void *)result;
44349   return jresult;
44350 }
44351
44352
44353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44354   void * jresult ;
44355   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44356   Dali::LinearConstrainer *arg2 = 0 ;
44357   Dali::LinearConstrainer *result = 0 ;
44358
44359   arg1 = (Dali::LinearConstrainer *)jarg1;
44360   arg2 = (Dali::LinearConstrainer *)jarg2;
44361   if (!arg2) {
44362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44363     return 0;
44364   }
44365   {
44366     try {
44367       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44368     } catch (std::out_of_range& e) {
44369       {
44370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44371       };
44372     } catch (std::exception& e) {
44373       {
44374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44375       };
44376     } catch (Dali::DaliException e) {
44377       {
44378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44379       };
44380     } catch (...) {
44381       {
44382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44383       };
44384     }
44385   }
44386
44387   jresult = (void *)result;
44388   return jresult;
44389 }
44390
44391
44392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44393   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44394   SwigValueWrapper< Dali::Property > arg2 ;
44395   SwigValueWrapper< Dali::Property > arg3 ;
44396   Dali::Vector2 *arg4 = 0 ;
44397   Dali::Vector2 *arg5 = 0 ;
44398   Dali::Property *argp2 ;
44399   Dali::Property *argp3 ;
44400
44401   arg1 = (Dali::LinearConstrainer *)jarg1;
44402   argp2 = (Dali::Property *)jarg2;
44403   if (!argp2) {
44404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44405     return ;
44406   }
44407   arg2 = *argp2;
44408   argp3 = (Dali::Property *)jarg3;
44409   if (!argp3) {
44410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44411     return ;
44412   }
44413   arg3 = *argp3;
44414   arg4 = (Dali::Vector2 *)jarg4;
44415   if (!arg4) {
44416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44417     return ;
44418   }
44419   arg5 = (Dali::Vector2 *)jarg5;
44420   if (!arg5) {
44421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44422     return ;
44423   }
44424   {
44425     try {
44426       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44427     } catch (std::out_of_range& e) {
44428       {
44429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44430       };
44431     } catch (std::exception& e) {
44432       {
44433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44434       };
44435     } catch (Dali::DaliException e) {
44436       {
44437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44438       };
44439     } catch (...) {
44440       {
44441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44442       };
44443     }
44444   }
44445
44446 }
44447
44448
44449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44450   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44451   SwigValueWrapper< Dali::Property > arg2 ;
44452   SwigValueWrapper< Dali::Property > arg3 ;
44453   Dali::Vector2 *arg4 = 0 ;
44454   Dali::Property *argp2 ;
44455   Dali::Property *argp3 ;
44456
44457   arg1 = (Dali::LinearConstrainer *)jarg1;
44458   argp2 = (Dali::Property *)jarg2;
44459   if (!argp2) {
44460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44461     return ;
44462   }
44463   arg2 = *argp2;
44464   argp3 = (Dali::Property *)jarg3;
44465   if (!argp3) {
44466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44467     return ;
44468   }
44469   arg3 = *argp3;
44470   arg4 = (Dali::Vector2 *)jarg4;
44471   if (!arg4) {
44472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44473     return ;
44474   }
44475   {
44476     try {
44477       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44478     } catch (std::out_of_range& e) {
44479       {
44480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44481       };
44482     } catch (std::exception& e) {
44483       {
44484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44485       };
44486     } catch (Dali::DaliException e) {
44487       {
44488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44489       };
44490     } catch (...) {
44491       {
44492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44493       };
44494     }
44495   }
44496
44497 }
44498
44499
44500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44501   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44502   Dali::Handle *arg2 = 0 ;
44503
44504   arg1 = (Dali::LinearConstrainer *)jarg1;
44505   arg2 = (Dali::Handle *)jarg2;
44506   if (!arg2) {
44507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44508     return ;
44509   }
44510   {
44511     try {
44512       (arg1)->Remove(*arg2);
44513     } catch (std::out_of_range& e) {
44514       {
44515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44516       };
44517     } catch (std::exception& e) {
44518       {
44519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44520       };
44521     } catch (Dali::DaliException e) {
44522       {
44523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44524       };
44525     } catch (...) {
44526       {
44527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44528       };
44529     }
44530   }
44531
44532 }
44533
44534
44535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44536   int jresult ;
44537   int result;
44538
44539   result = (int)Dali::PathConstrainer::Property::FORWARD;
44540   jresult = (int)result;
44541   return jresult;
44542 }
44543
44544
44545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44546   int jresult ;
44547   int result;
44548
44549   result = (int)Dali::PathConstrainer::Property::POINTS;
44550   jresult = (int)result;
44551   return jresult;
44552 }
44553
44554
44555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44556   int jresult ;
44557   int result;
44558
44559   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44560   jresult = (int)result;
44561   return jresult;
44562 }
44563
44564
44565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44566   void * jresult ;
44567   Dali::PathConstrainer::Property *result = 0 ;
44568
44569   {
44570     try {
44571       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44572     } catch (std::out_of_range& e) {
44573       {
44574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44575       };
44576     } catch (std::exception& e) {
44577       {
44578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44579       };
44580     } catch (Dali::DaliException e) {
44581       {
44582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44583       };
44584     } catch (...) {
44585       {
44586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44587       };
44588     }
44589   }
44590
44591   jresult = (void *)result;
44592   return jresult;
44593 }
44594
44595
44596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44597   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44598
44599   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44600   {
44601     try {
44602       delete arg1;
44603     } catch (std::out_of_range& e) {
44604       {
44605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44606       };
44607     } catch (std::exception& e) {
44608       {
44609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44610       };
44611     } catch (Dali::DaliException e) {
44612       {
44613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44614       };
44615     } catch (...) {
44616       {
44617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44618       };
44619     }
44620   }
44621
44622 }
44623
44624
44625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44626   void * jresult ;
44627   Dali::PathConstrainer result;
44628
44629   {
44630     try {
44631       result = Dali::PathConstrainer::New();
44632     } catch (std::out_of_range& e) {
44633       {
44634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44635       };
44636     } catch (std::exception& e) {
44637       {
44638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44639       };
44640     } catch (Dali::DaliException e) {
44641       {
44642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44643       };
44644     } catch (...) {
44645       {
44646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44647       };
44648     }
44649   }
44650
44651   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44652   return jresult;
44653 }
44654
44655
44656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44657   void * jresult ;
44658   Dali::BaseHandle arg1 ;
44659   Dali::BaseHandle *argp1 ;
44660   Dali::PathConstrainer result;
44661
44662   argp1 = (Dali::BaseHandle *)jarg1;
44663   if (!argp1) {
44664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44665     return 0;
44666   }
44667   arg1 = *argp1;
44668   {
44669     try {
44670       result = Dali::PathConstrainer::DownCast(arg1);
44671     } catch (std::out_of_range& e) {
44672       {
44673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44674       };
44675     } catch (std::exception& e) {
44676       {
44677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44678       };
44679     } catch (Dali::DaliException e) {
44680       {
44681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44682       };
44683     } catch (...) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44686       };
44687     }
44688   }
44689
44690   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44691   return jresult;
44692 }
44693
44694
44695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44696   void * jresult ;
44697   Dali::PathConstrainer *result = 0 ;
44698
44699   {
44700     try {
44701       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44702     } catch (std::out_of_range& e) {
44703       {
44704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44705       };
44706     } catch (std::exception& e) {
44707       {
44708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44709       };
44710     } catch (Dali::DaliException e) {
44711       {
44712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44713       };
44714     } catch (...) {
44715       {
44716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44717       };
44718     }
44719   }
44720
44721   jresult = (void *)result;
44722   return jresult;
44723 }
44724
44725
44726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44727   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44728
44729   arg1 = (Dali::PathConstrainer *)jarg1;
44730   {
44731     try {
44732       delete arg1;
44733     } catch (std::out_of_range& e) {
44734       {
44735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44736       };
44737     } catch (std::exception& e) {
44738       {
44739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44740       };
44741     } catch (Dali::DaliException e) {
44742       {
44743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44744       };
44745     } catch (...) {
44746       {
44747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44748       };
44749     }
44750   }
44751
44752 }
44753
44754
44755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44756   void * jresult ;
44757   Dali::PathConstrainer *arg1 = 0 ;
44758   Dali::PathConstrainer *result = 0 ;
44759
44760   arg1 = (Dali::PathConstrainer *)jarg1;
44761   if (!arg1) {
44762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44763     return 0;
44764   }
44765   {
44766     try {
44767       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44768     } catch (std::out_of_range& e) {
44769       {
44770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44771       };
44772     } catch (std::exception& e) {
44773       {
44774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44775       };
44776     } catch (Dali::DaliException e) {
44777       {
44778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44779       };
44780     } catch (...) {
44781       {
44782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44783       };
44784     }
44785   }
44786
44787   jresult = (void *)result;
44788   return jresult;
44789 }
44790
44791
44792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44793   void * jresult ;
44794   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44795   Dali::PathConstrainer *arg2 = 0 ;
44796   Dali::PathConstrainer *result = 0 ;
44797
44798   arg1 = (Dali::PathConstrainer *)jarg1;
44799   arg2 = (Dali::PathConstrainer *)jarg2;
44800   if (!arg2) {
44801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44802     return 0;
44803   }
44804   {
44805     try {
44806       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44807     } catch (std::out_of_range& e) {
44808       {
44809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44810       };
44811     } catch (std::exception& e) {
44812       {
44813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44814       };
44815     } catch (Dali::DaliException e) {
44816       {
44817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44818       };
44819     } catch (...) {
44820       {
44821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44822       };
44823     }
44824   }
44825
44826   jresult = (void *)result;
44827   return jresult;
44828 }
44829
44830
44831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44832   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44833   SwigValueWrapper< Dali::Property > arg2 ;
44834   SwigValueWrapper< Dali::Property > arg3 ;
44835   Dali::Vector2 *arg4 = 0 ;
44836   Dali::Vector2 *arg5 = 0 ;
44837   Dali::Property *argp2 ;
44838   Dali::Property *argp3 ;
44839
44840   arg1 = (Dali::PathConstrainer *)jarg1;
44841   argp2 = (Dali::Property *)jarg2;
44842   if (!argp2) {
44843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44844     return ;
44845   }
44846   arg2 = *argp2;
44847   argp3 = (Dali::Property *)jarg3;
44848   if (!argp3) {
44849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44850     return ;
44851   }
44852   arg3 = *argp3;
44853   arg4 = (Dali::Vector2 *)jarg4;
44854   if (!arg4) {
44855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44856     return ;
44857   }
44858   arg5 = (Dali::Vector2 *)jarg5;
44859   if (!arg5) {
44860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44861     return ;
44862   }
44863   {
44864     try {
44865       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44866     } catch (std::out_of_range& e) {
44867       {
44868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44869       };
44870     } catch (std::exception& e) {
44871       {
44872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44873       };
44874     } catch (Dali::DaliException e) {
44875       {
44876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44877       };
44878     } catch (...) {
44879       {
44880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44881       };
44882     }
44883   }
44884
44885 }
44886
44887
44888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44889   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44890   SwigValueWrapper< Dali::Property > arg2 ;
44891   SwigValueWrapper< Dali::Property > arg3 ;
44892   Dali::Vector2 *arg4 = 0 ;
44893   Dali::Property *argp2 ;
44894   Dali::Property *argp3 ;
44895
44896   arg1 = (Dali::PathConstrainer *)jarg1;
44897   argp2 = (Dali::Property *)jarg2;
44898   if (!argp2) {
44899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44900     return ;
44901   }
44902   arg2 = *argp2;
44903   argp3 = (Dali::Property *)jarg3;
44904   if (!argp3) {
44905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44906     return ;
44907   }
44908   arg3 = *argp3;
44909   arg4 = (Dali::Vector2 *)jarg4;
44910   if (!arg4) {
44911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44912     return ;
44913   }
44914   {
44915     try {
44916       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44917     } catch (std::out_of_range& e) {
44918       {
44919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44920       };
44921     } catch (std::exception& e) {
44922       {
44923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44924       };
44925     } catch (Dali::DaliException e) {
44926       {
44927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44928       };
44929     } catch (...) {
44930       {
44931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44932       };
44933     }
44934   }
44935
44936 }
44937
44938
44939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44940   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44941   Dali::Handle *arg2 = 0 ;
44942
44943   arg1 = (Dali::PathConstrainer *)jarg1;
44944   arg2 = (Dali::Handle *)jarg2;
44945   if (!arg2) {
44946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44947     return ;
44948   }
44949   {
44950     try {
44951       (arg1)->Remove(*arg2);
44952     } catch (std::out_of_range& e) {
44953       {
44954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44955       };
44956     } catch (std::exception& e) {
44957       {
44958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44959       };
44960     } catch (Dali::DaliException e) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44963       };
44964     } catch (...) {
44965       {
44966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44967       };
44968     }
44969   }
44970
44971 }
44972
44973
44974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44975   int jresult ;
44976   Dali::FittingMode::Type result;
44977
44978   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44979   jresult = (int)result;
44980   return jresult;
44981 }
44982
44983
44984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44985   int jresult ;
44986   Dali::SamplingMode::Type result;
44987
44988   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44989   jresult = (int)result;
44990   return jresult;
44991 }
44992
44993
44994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44995   void * jresult ;
44996   Dali::BufferImage *result = 0 ;
44997
44998   {
44999     try {
45000       result = (Dali::BufferImage *)new Dali::BufferImage();
45001     } catch (std::out_of_range& e) {
45002       {
45003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45004       };
45005     } catch (std::exception& e) {
45006       {
45007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45008       };
45009     } catch (Dali::DaliException e) {
45010       {
45011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45012       };
45013     } catch (...) {
45014       {
45015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45016       };
45017     }
45018   }
45019
45020   jresult = (void *)result;
45021   return jresult;
45022 }
45023
45024
45025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45026   void * jresult ;
45027   unsigned int arg1 ;
45028   unsigned int arg2 ;
45029   Dali::Pixel::Format arg3 ;
45030   Dali::BufferImage result;
45031
45032   arg1 = (unsigned int)jarg1;
45033   arg2 = (unsigned int)jarg2;
45034   arg3 = (Dali::Pixel::Format)jarg3;
45035   {
45036     try {
45037       result = Dali::BufferImage::New(arg1,arg2,arg3);
45038     } catch (std::out_of_range& e) {
45039       {
45040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45041       };
45042     } catch (std::exception& e) {
45043       {
45044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45045       };
45046     } catch (Dali::DaliException e) {
45047       {
45048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45049       };
45050     } catch (...) {
45051       {
45052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45053       };
45054     }
45055   }
45056
45057   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45058   return jresult;
45059 }
45060
45061
45062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45063   void * jresult ;
45064   unsigned int arg1 ;
45065   unsigned int arg2 ;
45066   Dali::BufferImage result;
45067
45068   arg1 = (unsigned int)jarg1;
45069   arg2 = (unsigned int)jarg2;
45070   {
45071     try {
45072       result = Dali::BufferImage::New(arg1,arg2);
45073     } catch (std::out_of_range& e) {
45074       {
45075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45076       };
45077     } catch (std::exception& e) {
45078       {
45079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45080       };
45081     } catch (Dali::DaliException e) {
45082       {
45083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45084       };
45085     } catch (...) {
45086       {
45087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45088       };
45089     }
45090   }
45091
45092   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45093   return jresult;
45094 }
45095
45096
45097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45098   void * jresult ;
45099   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45100   unsigned int arg2 ;
45101   unsigned int arg3 ;
45102   Dali::Pixel::Format arg4 ;
45103   unsigned int arg5 ;
45104   Dali::BufferImage result;
45105
45106   arg1 = jarg1;
45107   arg2 = (unsigned int)jarg2;
45108   arg3 = (unsigned int)jarg3;
45109   arg4 = (Dali::Pixel::Format)jarg4;
45110   arg5 = (unsigned int)jarg5;
45111   {
45112     try {
45113       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45121       };
45122     } catch (Dali::DaliException e) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45125       };
45126     } catch (...) {
45127       {
45128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45129       };
45130     }
45131   }
45132
45133   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45134
45135
45136   return jresult;
45137 }
45138
45139
45140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45141   void * jresult ;
45142   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45143   unsigned int arg2 ;
45144   unsigned int arg3 ;
45145   Dali::Pixel::Format arg4 ;
45146   Dali::BufferImage result;
45147
45148   arg1 = jarg1;
45149   arg2 = (unsigned int)jarg2;
45150   arg3 = (unsigned int)jarg3;
45151   arg4 = (Dali::Pixel::Format)jarg4;
45152   {
45153     try {
45154       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45155     } catch (std::out_of_range& e) {
45156       {
45157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45158       };
45159     } catch (std::exception& e) {
45160       {
45161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45162       };
45163     } catch (Dali::DaliException e) {
45164       {
45165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45166       };
45167     } catch (...) {
45168       {
45169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45170       };
45171     }
45172   }
45173
45174   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45175
45176
45177   return jresult;
45178 }
45179
45180
45181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45182   void * jresult ;
45183   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45184   unsigned int arg2 ;
45185   unsigned int arg3 ;
45186   Dali::BufferImage result;
45187
45188   arg1 = jarg1;
45189   arg2 = (unsigned int)jarg2;
45190   arg3 = (unsigned int)jarg3;
45191   {
45192     try {
45193       result = Dali::BufferImage::New(arg1,arg2,arg3);
45194     } catch (std::out_of_range& e) {
45195       {
45196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45197       };
45198     } catch (std::exception& e) {
45199       {
45200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45201       };
45202     } catch (Dali::DaliException e) {
45203       {
45204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45209       };
45210     }
45211   }
45212
45213   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45214
45215
45216   return jresult;
45217 }
45218
45219
45220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45221   void * jresult ;
45222   Dali::BaseHandle arg1 ;
45223   Dali::BaseHandle *argp1 ;
45224   Dali::BufferImage result;
45225
45226   argp1 = (Dali::BaseHandle *)jarg1;
45227   if (!argp1) {
45228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45229     return 0;
45230   }
45231   arg1 = *argp1;
45232   {
45233     try {
45234       result = Dali::BufferImage::DownCast(arg1);
45235     } catch (std::out_of_range& e) {
45236       {
45237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (std::exception& e) {
45240       {
45241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45242       };
45243     } catch (Dali::DaliException e) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45246       };
45247     } catch (...) {
45248       {
45249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45250       };
45251     }
45252   }
45253
45254   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45260   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45261
45262   arg1 = (Dali::BufferImage *)jarg1;
45263   {
45264     try {
45265       delete arg1;
45266     } catch (std::out_of_range& e) {
45267       {
45268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45269       };
45270     } catch (std::exception& e) {
45271       {
45272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45273       };
45274     } catch (Dali::DaliException e) {
45275       {
45276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45277       };
45278     } catch (...) {
45279       {
45280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45281       };
45282     }
45283   }
45284
45285 }
45286
45287
45288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45289   void * jresult ;
45290   Dali::BufferImage *arg1 = 0 ;
45291   Dali::BufferImage *result = 0 ;
45292
45293   arg1 = (Dali::BufferImage *)jarg1;
45294   if (!arg1) {
45295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45296     return 0;
45297   }
45298   {
45299     try {
45300       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45301     } catch (std::out_of_range& e) {
45302       {
45303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45304       };
45305     } catch (std::exception& e) {
45306       {
45307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45308       };
45309     } catch (Dali::DaliException e) {
45310       {
45311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45312       };
45313     } catch (...) {
45314       {
45315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45316       };
45317     }
45318   }
45319
45320   jresult = (void *)result;
45321   return jresult;
45322 }
45323
45324
45325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45326   void * jresult ;
45327   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45328   Dali::BufferImage *arg2 = 0 ;
45329   Dali::BufferImage *result = 0 ;
45330
45331   arg1 = (Dali::BufferImage *)jarg1;
45332   arg2 = (Dali::BufferImage *)jarg2;
45333   if (!arg2) {
45334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45335     return 0;
45336   }
45337   {
45338     try {
45339       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45340     } catch (std::out_of_range& e) {
45341       {
45342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45343       };
45344     } catch (std::exception& e) {
45345       {
45346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45347       };
45348     } catch (Dali::DaliException e) {
45349       {
45350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45351       };
45352     } catch (...) {
45353       {
45354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45355       };
45356     }
45357   }
45358
45359   jresult = (void *)result;
45360   return jresult;
45361 }
45362
45363
45364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45365   void * jresult ;
45366   Dali::BufferImage result;
45367
45368   {
45369     try {
45370       result = Dali::BufferImage::WHITE();
45371     } catch (std::out_of_range& e) {
45372       {
45373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45374       };
45375     } catch (std::exception& e) {
45376       {
45377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45378       };
45379     } catch (Dali::DaliException e) {
45380       {
45381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45382       };
45383     } catch (...) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45386       };
45387     }
45388   }
45389
45390   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45391   return jresult;
45392 }
45393
45394
45395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45396   void * jresult ;
45397   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45398   Dali::PixelBuffer *result = 0 ;
45399
45400   arg1 = (Dali::BufferImage *)jarg1;
45401   {
45402     try {
45403       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45404     } catch (std::out_of_range& e) {
45405       {
45406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45407       };
45408     } catch (std::exception& e) {
45409       {
45410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45411       };
45412     } catch (Dali::DaliException e) {
45413       {
45414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45415       };
45416     } catch (...) {
45417       {
45418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45419       };
45420     }
45421   }
45422
45423   jresult = (void *)result;
45424   return jresult;
45425 }
45426
45427
45428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45429   unsigned int jresult ;
45430   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45431   unsigned int result;
45432
45433   arg1 = (Dali::BufferImage *)jarg1;
45434   {
45435     try {
45436       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45437     } catch (std::out_of_range& e) {
45438       {
45439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45440       };
45441     } catch (std::exception& e) {
45442       {
45443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45444       };
45445     } catch (Dali::DaliException e) {
45446       {
45447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45448       };
45449     } catch (...) {
45450       {
45451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45452       };
45453     }
45454   }
45455
45456   jresult = result;
45457   return jresult;
45458 }
45459
45460
45461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45462   unsigned int jresult ;
45463   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45464   unsigned int result;
45465
45466   arg1 = (Dali::BufferImage *)jarg1;
45467   {
45468     try {
45469       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45470     } catch (std::out_of_range& e) {
45471       {
45472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45473       };
45474     } catch (std::exception& e) {
45475       {
45476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45477       };
45478     } catch (Dali::DaliException e) {
45479       {
45480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45481       };
45482     } catch (...) {
45483       {
45484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45485       };
45486     }
45487   }
45488
45489   jresult = result;
45490   return jresult;
45491 }
45492
45493
45494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45495   int jresult ;
45496   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45497   Dali::Pixel::Format result;
45498
45499   arg1 = (Dali::BufferImage *)jarg1;
45500   {
45501     try {
45502       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45503     } catch (std::out_of_range& e) {
45504       {
45505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45506       };
45507     } catch (std::exception& e) {
45508       {
45509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45510       };
45511     } catch (Dali::DaliException e) {
45512       {
45513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45514       };
45515     } catch (...) {
45516       {
45517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45518       };
45519     }
45520   }
45521
45522   jresult = (int)result;
45523   return jresult;
45524 }
45525
45526
45527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45528   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45529
45530   arg1 = (Dali::BufferImage *)jarg1;
45531   {
45532     try {
45533       (arg1)->Update();
45534     } catch (std::out_of_range& e) {
45535       {
45536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45537       };
45538     } catch (std::exception& e) {
45539       {
45540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45541       };
45542     } catch (Dali::DaliException e) {
45543       {
45544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45545       };
45546     } catch (...) {
45547       {
45548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45549       };
45550     }
45551   }
45552
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45557   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45558   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45559   Dali::RectArea *argp2 ;
45560
45561   arg1 = (Dali::BufferImage *)jarg1;
45562   argp2 = (Dali::RectArea *)jarg2;
45563   if (!argp2) {
45564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45565     return ;
45566   }
45567   arg2 = *argp2;
45568   {
45569     try {
45570       (arg1)->Update(arg2);
45571     } catch (std::out_of_range& e) {
45572       {
45573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45574       };
45575     } catch (std::exception& e) {
45576       {
45577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45578       };
45579     } catch (Dali::DaliException e) {
45580       {
45581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45582       };
45583     } catch (...) {
45584       {
45585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45586       };
45587     }
45588   }
45589
45590 }
45591
45592
45593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45594   unsigned int jresult ;
45595   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45596   bool result;
45597
45598   arg1 = (Dali::BufferImage *)jarg1;
45599   {
45600     try {
45601       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45602     } catch (std::out_of_range& e) {
45603       {
45604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45605       };
45606     } catch (std::exception& e) {
45607       {
45608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45609       };
45610     } catch (Dali::DaliException e) {
45611       {
45612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45613       };
45614     } catch (...) {
45615       {
45616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45617       };
45618     }
45619   }
45620
45621   jresult = result;
45622   return jresult;
45623 }
45624
45625
45626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45627   void * jresult ;
45628   Dali::EncodedBufferImage *result = 0 ;
45629
45630   {
45631     try {
45632       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45633     } catch (std::out_of_range& e) {
45634       {
45635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45636       };
45637     } catch (std::exception& e) {
45638       {
45639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45640       };
45641     } catch (Dali::DaliException e) {
45642       {
45643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45644       };
45645     } catch (...) {
45646       {
45647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45648       };
45649     }
45650   }
45651
45652   jresult = (void *)result;
45653   return jresult;
45654 }
45655
45656
45657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45658   void * jresult ;
45659   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45660   std::size_t arg2 ;
45661   Dali::EncodedBufferImage result;
45662
45663   arg1 = (uint8_t *)jarg1;
45664   arg2 = (std::size_t)jarg2;
45665   {
45666     try {
45667       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45668     } catch (std::out_of_range& e) {
45669       {
45670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45671       };
45672     } catch (std::exception& e) {
45673       {
45674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45675       };
45676     } catch (Dali::DaliException e) {
45677       {
45678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45679       };
45680     } catch (...) {
45681       {
45682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45683       };
45684     }
45685   }
45686
45687   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45688   return jresult;
45689 }
45690
45691
45692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45693   void * jresult ;
45694   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45695   std::size_t arg2 ;
45696   Dali::ImageDimensions arg3 ;
45697   Dali::FittingMode::Type arg4 ;
45698   Dali::SamplingMode::Type arg5 ;
45699   bool arg6 ;
45700   Dali::ImageDimensions *argp3 ;
45701   Dali::EncodedBufferImage result;
45702
45703   arg1 = (uint8_t *)jarg1;
45704   arg2 = (std::size_t)jarg2;
45705   argp3 = (Dali::ImageDimensions *)jarg3;
45706   if (!argp3) {
45707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45708     return 0;
45709   }
45710   arg3 = *argp3;
45711   arg4 = (Dali::FittingMode::Type)jarg4;
45712   arg5 = (Dali::SamplingMode::Type)jarg5;
45713   arg6 = jarg6 ? true : false;
45714   {
45715     try {
45716       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45717     } catch (std::out_of_range& e) {
45718       {
45719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45720       };
45721     } catch (std::exception& e) {
45722       {
45723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45724       };
45725     } catch (Dali::DaliException e) {
45726       {
45727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45728       };
45729     } catch (...) {
45730       {
45731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45732       };
45733     }
45734   }
45735
45736   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45737   return jresult;
45738 }
45739
45740
45741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45742   void * jresult ;
45743   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45744   std::size_t arg2 ;
45745   Dali::ImageDimensions arg3 ;
45746   Dali::FittingMode::Type arg4 ;
45747   Dali::SamplingMode::Type arg5 ;
45748   Dali::ImageDimensions *argp3 ;
45749   Dali::EncodedBufferImage result;
45750
45751   arg1 = (uint8_t *)jarg1;
45752   arg2 = (std::size_t)jarg2;
45753   argp3 = (Dali::ImageDimensions *)jarg3;
45754   if (!argp3) {
45755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45756     return 0;
45757   }
45758   arg3 = *argp3;
45759   arg4 = (Dali::FittingMode::Type)jarg4;
45760   arg5 = (Dali::SamplingMode::Type)jarg5;
45761   {
45762     try {
45763       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45764     } catch (std::out_of_range& e) {
45765       {
45766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45767       };
45768     } catch (std::exception& e) {
45769       {
45770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45771       };
45772     } catch (Dali::DaliException e) {
45773       {
45774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45775       };
45776     } catch (...) {
45777       {
45778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45779       };
45780     }
45781   }
45782
45783   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45784   return jresult;
45785 }
45786
45787
45788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45789   void * jresult ;
45790   Dali::BaseHandle arg1 ;
45791   Dali::BaseHandle *argp1 ;
45792   Dali::EncodedBufferImage result;
45793
45794   argp1 = (Dali::BaseHandle *)jarg1;
45795   if (!argp1) {
45796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45797     return 0;
45798   }
45799   arg1 = *argp1;
45800   {
45801     try {
45802       result = Dali::EncodedBufferImage::DownCast(arg1);
45803     } catch (std::out_of_range& e) {
45804       {
45805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45806       };
45807     } catch (std::exception& e) {
45808       {
45809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45810       };
45811     } catch (Dali::DaliException e) {
45812       {
45813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45814       };
45815     } catch (...) {
45816       {
45817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45818       };
45819     }
45820   }
45821
45822   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45823   return jresult;
45824 }
45825
45826
45827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45828   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45829
45830   arg1 = (Dali::EncodedBufferImage *)jarg1;
45831   {
45832     try {
45833       delete arg1;
45834     } catch (std::out_of_range& e) {
45835       {
45836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45837       };
45838     } catch (std::exception& e) {
45839       {
45840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45841       };
45842     } catch (Dali::DaliException e) {
45843       {
45844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45845       };
45846     } catch (...) {
45847       {
45848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45849       };
45850     }
45851   }
45852
45853 }
45854
45855
45856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45857   void * jresult ;
45858   Dali::EncodedBufferImage *arg1 = 0 ;
45859   Dali::EncodedBufferImage *result = 0 ;
45860
45861   arg1 = (Dali::EncodedBufferImage *)jarg1;
45862   if (!arg1) {
45863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45864     return 0;
45865   }
45866   {
45867     try {
45868       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45869     } catch (std::out_of_range& e) {
45870       {
45871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45872       };
45873     } catch (std::exception& e) {
45874       {
45875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45876       };
45877     } catch (Dali::DaliException e) {
45878       {
45879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45880       };
45881     } catch (...) {
45882       {
45883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45884       };
45885     }
45886   }
45887
45888   jresult = (void *)result;
45889   return jresult;
45890 }
45891
45892
45893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45894   void * jresult ;
45895   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45896   Dali::EncodedBufferImage *arg2 = 0 ;
45897   Dali::EncodedBufferImage *result = 0 ;
45898
45899   arg1 = (Dali::EncodedBufferImage *)jarg1;
45900   arg2 = (Dali::EncodedBufferImage *)jarg2;
45901   if (!arg2) {
45902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45903     return 0;
45904   }
45905   {
45906     try {
45907       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45908     } catch (std::out_of_range& e) {
45909       {
45910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45911       };
45912     } catch (std::exception& e) {
45913       {
45914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45915       };
45916     } catch (Dali::DaliException e) {
45917       {
45918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45919       };
45920     } catch (...) {
45921       {
45922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45923       };
45924     }
45925   }
45926
45927   jresult = (void *)result;
45928   return jresult;
45929 }
45930
45931
45932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45933   void * jresult ;
45934   Dali::NativeImage *result = 0 ;
45935
45936   {
45937     try {
45938       result = (Dali::NativeImage *)new Dali::NativeImage();
45939     } catch (std::out_of_range& e) {
45940       {
45941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45942       };
45943     } catch (std::exception& e) {
45944       {
45945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45946       };
45947     } catch (Dali::DaliException e) {
45948       {
45949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45950       };
45951     } catch (...) {
45952       {
45953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45954       };
45955     }
45956   }
45957
45958   jresult = (void *)result;
45959   return jresult;
45960 }
45961
45962
45963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45964   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45965
45966   arg1 = (Dali::NativeImage *)jarg1;
45967   {
45968     try {
45969       delete arg1;
45970     } catch (std::out_of_range& e) {
45971       {
45972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45973       };
45974     } catch (std::exception& e) {
45975       {
45976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45977       };
45978     } catch (Dali::DaliException e) {
45979       {
45980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45981       };
45982     } catch (...) {
45983       {
45984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45985       };
45986     }
45987   }
45988
45989 }
45990
45991
45992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45993   void * jresult ;
45994   Dali::NativeImage *arg1 = 0 ;
45995   Dali::NativeImage *result = 0 ;
45996
45997   arg1 = (Dali::NativeImage *)jarg1;
45998   if (!arg1) {
45999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46000     return 0;
46001   }
46002   {
46003     try {
46004       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46005     } catch (std::out_of_range& e) {
46006       {
46007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46008       };
46009     } catch (std::exception& e) {
46010       {
46011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46012       };
46013     } catch (Dali::DaliException e) {
46014       {
46015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46016       };
46017     } catch (...) {
46018       {
46019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46020       };
46021     }
46022   }
46023
46024   jresult = (void *)result;
46025   return jresult;
46026 }
46027
46028
46029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46030   void * jresult ;
46031   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46032   Dali::NativeImage *arg2 = 0 ;
46033   Dali::NativeImage *result = 0 ;
46034
46035   arg1 = (Dali::NativeImage *)jarg1;
46036   arg2 = (Dali::NativeImage *)jarg2;
46037   if (!arg2) {
46038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46039     return 0;
46040   }
46041   {
46042     try {
46043       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46044     } catch (std::out_of_range& e) {
46045       {
46046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46047       };
46048     } catch (std::exception& e) {
46049       {
46050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46051       };
46052     } catch (Dali::DaliException e) {
46053       {
46054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46055       };
46056     } catch (...) {
46057       {
46058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46059       };
46060     }
46061   }
46062
46063   jresult = (void *)result;
46064   return jresult;
46065 }
46066
46067
46068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46069   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46070
46071   arg1 = (Dali::NativeImage *)jarg1;
46072   {
46073     try {
46074       (arg1)->CreateGlTexture();
46075     } catch (std::out_of_range& e) {
46076       {
46077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46078       };
46079     } catch (std::exception& e) {
46080       {
46081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46082       };
46083     } catch (Dali::DaliException e) {
46084       {
46085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46086       };
46087     } catch (...) {
46088       {
46089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46090       };
46091     }
46092   }
46093
46094 }
46095
46096
46097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46098   void * jresult ;
46099   NativeImageInterface *arg1 = 0 ;
46100   Dali::NativeImage result;
46101
46102   arg1 = (NativeImageInterface *)jarg1;
46103   if (!arg1) {
46104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46105     return 0;
46106   }
46107   {
46108     try {
46109       result = Dali::NativeImage::New(*arg1);
46110     } catch (std::out_of_range& e) {
46111       {
46112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46113       };
46114     } catch (std::exception& e) {
46115       {
46116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46117       };
46118     } catch (Dali::DaliException e) {
46119       {
46120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46121       };
46122     } catch (...) {
46123       {
46124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46125       };
46126     }
46127   }
46128
46129   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46130   return jresult;
46131 }
46132
46133
46134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46135   void * jresult ;
46136   Dali::BaseHandle arg1 ;
46137   Dali::BaseHandle *argp1 ;
46138   Dali::NativeImage result;
46139
46140   argp1 = (Dali::BaseHandle *)jarg1;
46141   if (!argp1) {
46142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46143     return 0;
46144   }
46145   arg1 = *argp1;
46146   {
46147     try {
46148       result = Dali::NativeImage::DownCast(arg1);
46149     } catch (std::out_of_range& e) {
46150       {
46151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46152       };
46153     } catch (std::exception& e) {
46154       {
46155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46156       };
46157     } catch (Dali::DaliException e) {
46158       {
46159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46160       };
46161     } catch (...) {
46162       {
46163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46164       };
46165     }
46166   }
46167
46168   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46169   return jresult;
46170 }
46171
46172
46173 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46174   char * jresult ;
46175   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46176   char *result = 0 ;
46177
46178   arg1 = (Dali::NativeImage *)jarg1;
46179   {
46180     try {
46181       result = (char *)(arg1)->GetCustomFragmentPreFix();
46182     } catch (std::out_of_range& e) {
46183       {
46184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46185       };
46186     } catch (std::exception& e) {
46187       {
46188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46189       };
46190     } catch (Dali::DaliException e) {
46191       {
46192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46193       };
46194     } catch (...) {
46195       {
46196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46197       };
46198     }
46199   }
46200
46201   jresult = SWIG_csharp_string_callback((const char *)result);
46202   return jresult;
46203 }
46204
46205
46206 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46207   char * jresult ;
46208   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46209   char *result = 0 ;
46210
46211   arg1 = (Dali::NativeImage *)jarg1;
46212   {
46213     try {
46214       result = (char *)(arg1)->GetCustomSamplerTypename();
46215     } catch (std::out_of_range& e) {
46216       {
46217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46218       };
46219     } catch (std::exception& e) {
46220       {
46221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46222       };
46223     } catch (Dali::DaliException e) {
46224       {
46225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46226       };
46227     } catch (...) {
46228       {
46229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46230       };
46231     }
46232   }
46233
46234   jresult = SWIG_csharp_string_callback((const char *)result);
46235   return jresult;
46236 }
46237
46238
46239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46240   unsigned int jresult ;
46241   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46242   bool result;
46243
46244   arg1 = (Dali::NativeImageInterface *)jarg1;
46245   {
46246     try {
46247       result = (bool)(arg1)->GlExtensionCreate();
46248     } catch (std::out_of_range& e) {
46249       {
46250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46251       };
46252     } catch (std::exception& e) {
46253       {
46254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46255       };
46256     } catch (Dali::DaliException e) {
46257       {
46258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46259       };
46260     } catch (...) {
46261       {
46262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46263       };
46264     }
46265   }
46266
46267   jresult = result;
46268   return jresult;
46269 }
46270
46271
46272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46273   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46274
46275   arg1 = (Dali::NativeImageInterface *)jarg1;
46276   {
46277     try {
46278       (arg1)->GlExtensionDestroy();
46279     } catch (std::out_of_range& e) {
46280       {
46281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46282       };
46283     } catch (std::exception& e) {
46284       {
46285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46286       };
46287     } catch (Dali::DaliException e) {
46288       {
46289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46290       };
46291     } catch (...) {
46292       {
46293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46294       };
46295     }
46296   }
46297
46298 }
46299
46300
46301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46302   unsigned int jresult ;
46303   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46304   unsigned int result;
46305
46306   arg1 = (Dali::NativeImageInterface *)jarg1;
46307   {
46308     try {
46309       result = (unsigned int)(arg1)->TargetTexture();
46310     } catch (std::out_of_range& e) {
46311       {
46312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46313       };
46314     } catch (std::exception& e) {
46315       {
46316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46317       };
46318     } catch (Dali::DaliException e) {
46319       {
46320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46321       };
46322     } catch (...) {
46323       {
46324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46325       };
46326     }
46327   }
46328
46329   jresult = result;
46330   return jresult;
46331 }
46332
46333
46334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46335   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46336
46337   arg1 = (Dali::NativeImageInterface *)jarg1;
46338   {
46339     try {
46340       (arg1)->PrepareTexture();
46341     } catch (std::out_of_range& e) {
46342       {
46343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46344       };
46345     } catch (std::exception& e) {
46346       {
46347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46348       };
46349     } catch (Dali::DaliException e) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46352       };
46353     } catch (...) {
46354       {
46355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46356       };
46357     }
46358   }
46359
46360 }
46361
46362
46363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46364   unsigned int jresult ;
46365   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46366   unsigned int result;
46367
46368   arg1 = (Dali::NativeImageInterface *)jarg1;
46369   {
46370     try {
46371       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46372     } catch (std::out_of_range& e) {
46373       {
46374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46375       };
46376     } catch (std::exception& e) {
46377       {
46378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46379       };
46380     } catch (Dali::DaliException e) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46383       };
46384     } catch (...) {
46385       {
46386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46387       };
46388     }
46389   }
46390
46391   jresult = result;
46392   return jresult;
46393 }
46394
46395
46396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46397   unsigned int jresult ;
46398   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46399   unsigned int result;
46400
46401   arg1 = (Dali::NativeImageInterface *)jarg1;
46402   {
46403     try {
46404       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46405     } catch (std::out_of_range& e) {
46406       {
46407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46408       };
46409     } catch (std::exception& e) {
46410       {
46411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46412       };
46413     } catch (Dali::DaliException e) {
46414       {
46415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46416       };
46417     } catch (...) {
46418       {
46419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46420       };
46421     }
46422   }
46423
46424   jresult = result;
46425   return jresult;
46426 }
46427
46428
46429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46430   unsigned int jresult ;
46431   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46432   bool result;
46433
46434   arg1 = (Dali::NativeImageInterface *)jarg1;
46435   {
46436     try {
46437       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46438     } catch (std::out_of_range& e) {
46439       {
46440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46441       };
46442     } catch (std::exception& e) {
46443       {
46444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46445       };
46446     } catch (Dali::DaliException e) {
46447       {
46448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46449       };
46450     } catch (...) {
46451       {
46452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46453       };
46454     }
46455   }
46456
46457   jresult = result;
46458   return jresult;
46459 }
46460
46461
46462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46463   void * jresult ;
46464   std::string *arg1 = 0 ;
46465   Dali::ImageDimensions result;
46466
46467   if (!jarg1) {
46468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46469     return 0;
46470   }
46471   std::string arg1_str(jarg1);
46472   arg1 = &arg1_str;
46473   {
46474     try {
46475       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46476     } catch (std::out_of_range& e) {
46477       {
46478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46479       };
46480     } catch (std::exception& e) {
46481       {
46482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46483       };
46484     } catch (Dali::DaliException e) {
46485       {
46486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46487       };
46488     } catch (...) {
46489       {
46490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46491       };
46492     }
46493   }
46494
46495   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46496
46497   //argout typemap for const std::string&
46498
46499   return jresult;
46500 }
46501
46502
46503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46504   void * jresult ;
46505   Dali::ResourceImage *result = 0 ;
46506
46507   {
46508     try {
46509       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46510     } catch (std::out_of_range& e) {
46511       {
46512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46513       };
46514     } catch (std::exception& e) {
46515       {
46516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46517       };
46518     } catch (Dali::DaliException e) {
46519       {
46520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46521       };
46522     } catch (...) {
46523       {
46524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46525       };
46526     }
46527   }
46528
46529   jresult = (void *)result;
46530   return jresult;
46531 }
46532
46533
46534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46535   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46536
46537   arg1 = (Dali::ResourceImage *)jarg1;
46538   {
46539     try {
46540       delete arg1;
46541     } catch (std::out_of_range& e) {
46542       {
46543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46544       };
46545     } catch (std::exception& e) {
46546       {
46547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46548       };
46549     } catch (Dali::DaliException e) {
46550       {
46551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46552       };
46553     } catch (...) {
46554       {
46555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46556       };
46557     }
46558   }
46559
46560 }
46561
46562
46563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46564   void * jresult ;
46565   Dali::ResourceImage *arg1 = 0 ;
46566   Dali::ResourceImage *result = 0 ;
46567
46568   arg1 = (Dali::ResourceImage *)jarg1;
46569   if (!arg1) {
46570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46571     return 0;
46572   }
46573   {
46574     try {
46575       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46576     } catch (std::out_of_range& e) {
46577       {
46578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46579       };
46580     } catch (std::exception& e) {
46581       {
46582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46583       };
46584     } catch (Dali::DaliException e) {
46585       {
46586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46587       };
46588     } catch (...) {
46589       {
46590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46591       };
46592     }
46593   }
46594
46595   jresult = (void *)result;
46596   return jresult;
46597 }
46598
46599
46600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46601   void * jresult ;
46602   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46603   Dali::ResourceImage *arg2 = 0 ;
46604   Dali::ResourceImage *result = 0 ;
46605
46606   arg1 = (Dali::ResourceImage *)jarg1;
46607   arg2 = (Dali::ResourceImage *)jarg2;
46608   if (!arg2) {
46609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46610     return 0;
46611   }
46612   {
46613     try {
46614       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46615     } catch (std::out_of_range& e) {
46616       {
46617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46618       };
46619     } catch (std::exception& e) {
46620       {
46621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46622       };
46623     } catch (Dali::DaliException e) {
46624       {
46625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46626       };
46627     } catch (...) {
46628       {
46629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46630       };
46631     }
46632   }
46633
46634   jresult = (void *)result;
46635   return jresult;
46636 }
46637
46638
46639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46640   void * jresult ;
46641   std::string *arg1 = 0 ;
46642   bool arg2 ;
46643   Dali::ResourceImage result;
46644
46645   if (!jarg1) {
46646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46647     return 0;
46648   }
46649   std::string arg1_str(jarg1);
46650   arg1 = &arg1_str;
46651   arg2 = jarg2 ? true : false;
46652   {
46653     try {
46654       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46655     } catch (std::out_of_range& e) {
46656       {
46657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46658       };
46659     } catch (std::exception& e) {
46660       {
46661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (Dali::DaliException e) {
46664       {
46665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46666       };
46667     } catch (...) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46670       };
46671     }
46672   }
46673
46674   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46675
46676   //argout typemap for const std::string&
46677
46678   return jresult;
46679 }
46680
46681
46682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46683   void * jresult ;
46684   std::string *arg1 = 0 ;
46685   Dali::ResourceImage result;
46686
46687   if (!jarg1) {
46688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46689     return 0;
46690   }
46691   std::string arg1_str(jarg1);
46692   arg1 = &arg1_str;
46693   {
46694     try {
46695       result = Dali::ResourceImage::New((std::string const &)*arg1);
46696     } catch (std::out_of_range& e) {
46697       {
46698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46699       };
46700     } catch (std::exception& e) {
46701       {
46702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46703       };
46704     } catch (Dali::DaliException e) {
46705       {
46706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46707       };
46708     } catch (...) {
46709       {
46710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46711       };
46712     }
46713   }
46714
46715   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46716
46717   //argout typemap for const std::string&
46718
46719   return jresult;
46720 }
46721
46722
46723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46724   void * jresult ;
46725   std::string *arg1 = 0 ;
46726   Dali::ImageDimensions arg2 ;
46727   Dali::FittingMode::Type arg3 ;
46728   Dali::SamplingMode::Type arg4 ;
46729   bool arg5 ;
46730   Dali::ImageDimensions *argp2 ;
46731   Dali::ResourceImage result;
46732
46733   if (!jarg1) {
46734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46735     return 0;
46736   }
46737   std::string arg1_str(jarg1);
46738   arg1 = &arg1_str;
46739   argp2 = (Dali::ImageDimensions *)jarg2;
46740   if (!argp2) {
46741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46742     return 0;
46743   }
46744   arg2 = *argp2;
46745   arg3 = (Dali::FittingMode::Type)jarg3;
46746   arg4 = (Dali::SamplingMode::Type)jarg4;
46747   arg5 = jarg5 ? true : false;
46748   {
46749     try {
46750       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46751     } catch (std::out_of_range& e) {
46752       {
46753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46754       };
46755     } catch (std::exception& e) {
46756       {
46757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46758       };
46759     } catch (Dali::DaliException e) {
46760       {
46761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46762       };
46763     } catch (...) {
46764       {
46765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46766       };
46767     }
46768   }
46769
46770   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46771
46772   //argout typemap for const std::string&
46773
46774   return jresult;
46775 }
46776
46777
46778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46779   void * jresult ;
46780   std::string *arg1 = 0 ;
46781   Dali::ImageDimensions arg2 ;
46782   Dali::FittingMode::Type arg3 ;
46783   Dali::SamplingMode::Type arg4 ;
46784   Dali::ImageDimensions *argp2 ;
46785   Dali::ResourceImage result;
46786
46787   if (!jarg1) {
46788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46789     return 0;
46790   }
46791   std::string arg1_str(jarg1);
46792   arg1 = &arg1_str;
46793   argp2 = (Dali::ImageDimensions *)jarg2;
46794   if (!argp2) {
46795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46796     return 0;
46797   }
46798   arg2 = *argp2;
46799   arg3 = (Dali::FittingMode::Type)jarg3;
46800   arg4 = (Dali::SamplingMode::Type)jarg4;
46801   {
46802     try {
46803       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46804     } catch (std::out_of_range& e) {
46805       {
46806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46807       };
46808     } catch (std::exception& e) {
46809       {
46810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46811       };
46812     } catch (Dali::DaliException e) {
46813       {
46814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46815       };
46816     } catch (...) {
46817       {
46818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46819       };
46820     }
46821   }
46822
46823   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46824
46825   //argout typemap for const std::string&
46826
46827   return jresult;
46828 }
46829
46830
46831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46832   void * jresult ;
46833   std::string *arg1 = 0 ;
46834   Dali::ImageDimensions arg2 ;
46835   Dali::FittingMode::Type arg3 ;
46836   Dali::ImageDimensions *argp2 ;
46837   Dali::ResourceImage result;
46838
46839   if (!jarg1) {
46840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46841     return 0;
46842   }
46843   std::string arg1_str(jarg1);
46844   arg1 = &arg1_str;
46845   argp2 = (Dali::ImageDimensions *)jarg2;
46846   if (!argp2) {
46847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46848     return 0;
46849   }
46850   arg2 = *argp2;
46851   arg3 = (Dali::FittingMode::Type)jarg3;
46852   {
46853     try {
46854       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46855     } catch (std::out_of_range& e) {
46856       {
46857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46858       };
46859     } catch (std::exception& e) {
46860       {
46861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46862       };
46863     } catch (Dali::DaliException e) {
46864       {
46865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46866       };
46867     } catch (...) {
46868       {
46869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46870       };
46871     }
46872   }
46873
46874   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46875
46876   //argout typemap for const std::string&
46877
46878   return jresult;
46879 }
46880
46881
46882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46883   void * jresult ;
46884   std::string *arg1 = 0 ;
46885   Dali::ImageDimensions arg2 ;
46886   Dali::ImageDimensions *argp2 ;
46887   Dali::ResourceImage result;
46888
46889   if (!jarg1) {
46890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46891     return 0;
46892   }
46893   std::string arg1_str(jarg1);
46894   arg1 = &arg1_str;
46895   argp2 = (Dali::ImageDimensions *)jarg2;
46896   if (!argp2) {
46897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46898     return 0;
46899   }
46900   arg2 = *argp2;
46901   {
46902     try {
46903       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46904     } catch (std::out_of_range& e) {
46905       {
46906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46907       };
46908     } catch (std::exception& e) {
46909       {
46910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46911       };
46912     } catch (Dali::DaliException e) {
46913       {
46914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46915       };
46916     } catch (...) {
46917       {
46918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46919       };
46920     }
46921   }
46922
46923   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46924
46925   //argout typemap for const std::string&
46926
46927   return jresult;
46928 }
46929
46930
46931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46932   void * jresult ;
46933   Dali::BaseHandle arg1 ;
46934   Dali::BaseHandle *argp1 ;
46935   Dali::ResourceImage result;
46936
46937   argp1 = (Dali::BaseHandle *)jarg1;
46938   if (!argp1) {
46939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46940     return 0;
46941   }
46942   arg1 = *argp1;
46943   {
46944     try {
46945       result = Dali::ResourceImage::DownCast(arg1);
46946     } catch (std::out_of_range& e) {
46947       {
46948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46949       };
46950     } catch (std::exception& e) {
46951       {
46952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46953       };
46954     } catch (Dali::DaliException e) {
46955       {
46956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46957       };
46958     } catch (...) {
46959       {
46960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46961       };
46962     }
46963   }
46964
46965   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46966   return jresult;
46967 }
46968
46969
46970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46971   int jresult ;
46972   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46973   Dali::LoadingState result;
46974
46975   arg1 = (Dali::ResourceImage *)jarg1;
46976   {
46977     try {
46978       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46979     } catch (std::out_of_range& e) {
46980       {
46981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46982       };
46983     } catch (std::exception& e) {
46984       {
46985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46986       };
46987     } catch (Dali::DaliException e) {
46988       {
46989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46990       };
46991     } catch (...) {
46992       {
46993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46994       };
46995     }
46996   }
46997
46998   jresult = (int)result;
46999   return jresult;
47000 }
47001
47002
47003 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47004   char * jresult ;
47005   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47006   std::string result;
47007
47008   arg1 = (Dali::ResourceImage *)jarg1;
47009   {
47010     try {
47011       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47012     } catch (std::out_of_range& e) {
47013       {
47014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47015       };
47016     } catch (std::exception& e) {
47017       {
47018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47019       };
47020     } catch (Dali::DaliException e) {
47021       {
47022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47023       };
47024     } catch (...) {
47025       {
47026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47027       };
47028     }
47029   }
47030
47031   jresult = SWIG_csharp_string_callback((&result)->c_str());
47032   return jresult;
47033 }
47034
47035
47036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47037   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47038
47039   arg1 = (Dali::ResourceImage *)jarg1;
47040   {
47041     try {
47042       (arg1)->Reload();
47043     } catch (std::out_of_range& e) {
47044       {
47045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47046       };
47047     } catch (std::exception& e) {
47048       {
47049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47050       };
47051     } catch (Dali::DaliException e) {
47052       {
47053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47054       };
47055     } catch (...) {
47056       {
47057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47058       };
47059     }
47060   }
47061
47062 }
47063
47064
47065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47066   void * jresult ;
47067   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47068   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47069
47070   arg1 = (Dali::ResourceImage *)jarg1;
47071   {
47072     try {
47073       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47074     } catch (std::out_of_range& e) {
47075       {
47076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47077       };
47078     } catch (std::exception& e) {
47079       {
47080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47081       };
47082     } catch (Dali::DaliException e) {
47083       {
47084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47085       };
47086     } catch (...) {
47087       {
47088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47089       };
47090     }
47091   }
47092
47093   jresult = (void *)result;
47094   return jresult;
47095 }
47096
47097
47098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47099   void * jresult ;
47100   Dali::FrameBufferImage *result = 0 ;
47101
47102   {
47103     try {
47104       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47105     } catch (std::out_of_range& e) {
47106       {
47107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (std::exception& e) {
47110       {
47111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47112       };
47113     } catch (Dali::DaliException e) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47116       };
47117     } catch (...) {
47118       {
47119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47120       };
47121     }
47122   }
47123
47124   jresult = (void *)result;
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47130   void * jresult ;
47131   unsigned int arg1 ;
47132   unsigned int arg2 ;
47133   Dali::Pixel::Format arg3 ;
47134   Dali::RenderBuffer::Format arg4 ;
47135   Dali::FrameBufferImage result;
47136
47137   arg1 = (unsigned int)jarg1;
47138   arg2 = (unsigned int)jarg2;
47139   arg3 = (Dali::Pixel::Format)jarg3;
47140   arg4 = (Dali::RenderBuffer::Format)jarg4;
47141   {
47142     try {
47143       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47144     } catch (std::out_of_range& e) {
47145       {
47146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47147       };
47148     } catch (std::exception& e) {
47149       {
47150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47151       };
47152     } catch (Dali::DaliException e) {
47153       {
47154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47155       };
47156     } catch (...) {
47157       {
47158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47159       };
47160     }
47161   }
47162
47163   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47169   void * jresult ;
47170   unsigned int arg1 ;
47171   unsigned int arg2 ;
47172   Dali::Pixel::Format arg3 ;
47173   Dali::FrameBufferImage result;
47174
47175   arg1 = (unsigned int)jarg1;
47176   arg2 = (unsigned int)jarg2;
47177   arg3 = (Dali::Pixel::Format)jarg3;
47178   {
47179     try {
47180       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47181     } catch (std::out_of_range& e) {
47182       {
47183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47184       };
47185     } catch (std::exception& e) {
47186       {
47187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47188       };
47189     } catch (Dali::DaliException e) {
47190       {
47191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47192       };
47193     } catch (...) {
47194       {
47195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47196       };
47197     }
47198   }
47199
47200   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47201   return jresult;
47202 }
47203
47204
47205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47206   void * jresult ;
47207   unsigned int arg1 ;
47208   unsigned int arg2 ;
47209   Dali::FrameBufferImage result;
47210
47211   arg1 = (unsigned int)jarg1;
47212   arg2 = (unsigned int)jarg2;
47213   {
47214     try {
47215       result = Dali::FrameBufferImage::New(arg1,arg2);
47216     } catch (std::out_of_range& e) {
47217       {
47218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47219       };
47220     } catch (std::exception& e) {
47221       {
47222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47223       };
47224     } catch (Dali::DaliException e) {
47225       {
47226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47227       };
47228     } catch (...) {
47229       {
47230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47231       };
47232     }
47233   }
47234
47235   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47236   return jresult;
47237 }
47238
47239
47240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47241   void * jresult ;
47242   unsigned int arg1 ;
47243   Dali::FrameBufferImage result;
47244
47245   arg1 = (unsigned int)jarg1;
47246   {
47247     try {
47248       result = Dali::FrameBufferImage::New(arg1);
47249     } catch (std::out_of_range& e) {
47250       {
47251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47252       };
47253     } catch (std::exception& e) {
47254       {
47255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47256       };
47257     } catch (Dali::DaliException e) {
47258       {
47259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47260       };
47261     } catch (...) {
47262       {
47263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47264       };
47265     }
47266   }
47267
47268   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47269   return jresult;
47270 }
47271
47272
47273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47274   void * jresult ;
47275   Dali::FrameBufferImage result;
47276
47277   {
47278     try {
47279       result = Dali::FrameBufferImage::New();
47280     } catch (std::out_of_range& e) {
47281       {
47282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47283       };
47284     } catch (std::exception& e) {
47285       {
47286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47287       };
47288     } catch (Dali::DaliException e) {
47289       {
47290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47291       };
47292     } catch (...) {
47293       {
47294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47295       };
47296     }
47297   }
47298
47299   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47300   return jresult;
47301 }
47302
47303
47304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47305   void * jresult ;
47306   Dali::NativeImageInterface *arg1 = 0 ;
47307   Dali::FrameBufferImage result;
47308
47309   arg1 = (Dali::NativeImageInterface *)jarg1;
47310   if (!arg1) {
47311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47312     return 0;
47313   }
47314   {
47315     try {
47316       result = Dali::FrameBufferImage::New(*arg1);
47317     } catch (std::out_of_range& e) {
47318       {
47319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47320       };
47321     } catch (std::exception& e) {
47322       {
47323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (Dali::DaliException e) {
47326       {
47327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47332       };
47333     }
47334   }
47335
47336   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47337   return jresult;
47338 }
47339
47340
47341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47342   void * jresult ;
47343   Dali::BaseHandle arg1 ;
47344   Dali::BaseHandle *argp1 ;
47345   Dali::FrameBufferImage result;
47346
47347   argp1 = (Dali::BaseHandle *)jarg1;
47348   if (!argp1) {
47349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47350     return 0;
47351   }
47352   arg1 = *argp1;
47353   {
47354     try {
47355       result = Dali::FrameBufferImage::DownCast(arg1);
47356     } catch (std::out_of_range& e) {
47357       {
47358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47359       };
47360     } catch (std::exception& e) {
47361       {
47362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47363       };
47364     } catch (Dali::DaliException e) {
47365       {
47366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47367       };
47368     } catch (...) {
47369       {
47370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47371       };
47372     }
47373   }
47374
47375   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47376   return jresult;
47377 }
47378
47379
47380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47381   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47382
47383   arg1 = (Dali::FrameBufferImage *)jarg1;
47384   {
47385     try {
47386       delete arg1;
47387     } catch (std::out_of_range& e) {
47388       {
47389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47390       };
47391     } catch (std::exception& e) {
47392       {
47393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47394       };
47395     } catch (Dali::DaliException e) {
47396       {
47397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47398       };
47399     } catch (...) {
47400       {
47401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47402       };
47403     }
47404   }
47405
47406 }
47407
47408
47409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47410   void * jresult ;
47411   Dali::FrameBufferImage *arg1 = 0 ;
47412   Dali::FrameBufferImage *result = 0 ;
47413
47414   arg1 = (Dali::FrameBufferImage *)jarg1;
47415   if (!arg1) {
47416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47417     return 0;
47418   }
47419   {
47420     try {
47421       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47422     } catch (std::out_of_range& e) {
47423       {
47424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47425       };
47426     } catch (std::exception& e) {
47427       {
47428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47429       };
47430     } catch (Dali::DaliException e) {
47431       {
47432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47433       };
47434     } catch (...) {
47435       {
47436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47437       };
47438     }
47439   }
47440
47441   jresult = (void *)result;
47442   return jresult;
47443 }
47444
47445
47446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47447   void * jresult ;
47448   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47449   Dali::FrameBufferImage *arg2 = 0 ;
47450   Dali::FrameBufferImage *result = 0 ;
47451
47452   arg1 = (Dali::FrameBufferImage *)jarg1;
47453   arg2 = (Dali::FrameBufferImage *)jarg2;
47454   if (!arg2) {
47455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47456     return 0;
47457   }
47458   {
47459     try {
47460       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47461     } catch (std::out_of_range& e) {
47462       {
47463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47464       };
47465     } catch (std::exception& e) {
47466       {
47467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47468       };
47469     } catch (Dali::DaliException e) {
47470       {
47471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47472       };
47473     } catch (...) {
47474       {
47475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47476       };
47477     }
47478   }
47479
47480   jresult = (void *)result;
47481   return jresult;
47482 }
47483
47484
47485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47486   void * jresult ;
47487   Dali::NinePatchImage *result = 0 ;
47488
47489   {
47490     try {
47491       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47492     } catch (std::out_of_range& e) {
47493       {
47494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47495       };
47496     } catch (std::exception& e) {
47497       {
47498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47499       };
47500     } catch (Dali::DaliException e) {
47501       {
47502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47503       };
47504     } catch (...) {
47505       {
47506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47507       };
47508     }
47509   }
47510
47511   jresult = (void *)result;
47512   return jresult;
47513 }
47514
47515
47516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47517   void * jresult ;
47518   std::string *arg1 = 0 ;
47519   Dali::NinePatchImage result;
47520
47521   if (!jarg1) {
47522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47523     return 0;
47524   }
47525   std::string arg1_str(jarg1);
47526   arg1 = &arg1_str;
47527   {
47528     try {
47529       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47530     } catch (std::out_of_range& e) {
47531       {
47532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47533       };
47534     } catch (std::exception& e) {
47535       {
47536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47537       };
47538     } catch (Dali::DaliException e) {
47539       {
47540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47541       };
47542     } catch (...) {
47543       {
47544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47545       };
47546     }
47547   }
47548
47549   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47550
47551   //argout typemap for const std::string&
47552
47553   return jresult;
47554 }
47555
47556
47557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47558   void * jresult ;
47559   Dali::BaseHandle arg1 ;
47560   Dali::BaseHandle *argp1 ;
47561   Dali::NinePatchImage result;
47562
47563   argp1 = (Dali::BaseHandle *)jarg1;
47564   if (!argp1) {
47565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47566     return 0;
47567   }
47568   arg1 = *argp1;
47569   {
47570     try {
47571       result = Dali::NinePatchImage::DownCast(arg1);
47572     } catch (std::out_of_range& e) {
47573       {
47574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47575       };
47576     } catch (std::exception& e) {
47577       {
47578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47579       };
47580     } catch (Dali::DaliException e) {
47581       {
47582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47583       };
47584     } catch (...) {
47585       {
47586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47587       };
47588     }
47589   }
47590
47591   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47592   return jresult;
47593 }
47594
47595
47596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47597   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47598
47599   arg1 = (Dali::NinePatchImage *)jarg1;
47600   {
47601     try {
47602       delete arg1;
47603     } catch (std::out_of_range& e) {
47604       {
47605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47606       };
47607     } catch (std::exception& e) {
47608       {
47609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47610       };
47611     } catch (Dali::DaliException e) {
47612       {
47613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47614       };
47615     } catch (...) {
47616       {
47617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47618       };
47619     }
47620   }
47621
47622 }
47623
47624
47625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47626   void * jresult ;
47627   Dali::NinePatchImage *arg1 = 0 ;
47628   Dali::NinePatchImage *result = 0 ;
47629
47630   arg1 = (Dali::NinePatchImage *)jarg1;
47631   if (!arg1) {
47632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47633     return 0;
47634   }
47635   {
47636     try {
47637       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47638     } catch (std::out_of_range& e) {
47639       {
47640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47641       };
47642     } catch (std::exception& e) {
47643       {
47644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47645       };
47646     } catch (Dali::DaliException e) {
47647       {
47648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47649       };
47650     } catch (...) {
47651       {
47652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47653       };
47654     }
47655   }
47656
47657   jresult = (void *)result;
47658   return jresult;
47659 }
47660
47661
47662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47663   void * jresult ;
47664   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47665   Dali::NinePatchImage *arg2 = 0 ;
47666   Dali::NinePatchImage *result = 0 ;
47667
47668   arg1 = (Dali::NinePatchImage *)jarg1;
47669   arg2 = (Dali::NinePatchImage *)jarg2;
47670   if (!arg2) {
47671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47672     return 0;
47673   }
47674   {
47675     try {
47676       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47677     } catch (std::out_of_range& e) {
47678       {
47679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47680       };
47681     } catch (std::exception& e) {
47682       {
47683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47684       };
47685     } catch (Dali::DaliException e) {
47686       {
47687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47688       };
47689     } catch (...) {
47690       {
47691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47692       };
47693     }
47694   }
47695
47696   jresult = (void *)result;
47697   return jresult;
47698 }
47699
47700
47701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47702   void * jresult ;
47703   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47704   Dali::Vector4 result;
47705
47706   arg1 = (Dali::NinePatchImage *)jarg1;
47707   {
47708     try {
47709       result = (arg1)->GetStretchBorders();
47710     } catch (std::out_of_range& e) {
47711       {
47712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47713       };
47714     } catch (std::exception& e) {
47715       {
47716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47717       };
47718     } catch (Dali::DaliException e) {
47719       {
47720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47721       };
47722     } catch (...) {
47723       {
47724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47725       };
47726     }
47727   }
47728
47729   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47730   return jresult;
47731 }
47732
47733
47734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47735   void * jresult ;
47736   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47737   Dali::NinePatchImage::StretchRanges *result = 0 ;
47738
47739   arg1 = (Dali::NinePatchImage *)jarg1;
47740   {
47741     try {
47742       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47743     } catch (std::out_of_range& e) {
47744       {
47745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47746       };
47747     } catch (std::exception& e) {
47748       {
47749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47750       };
47751     } catch (Dali::DaliException e) {
47752       {
47753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47754       };
47755     } catch (...) {
47756       {
47757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47758       };
47759     }
47760   }
47761
47762   jresult = (void *)result;
47763   return jresult;
47764 }
47765
47766
47767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47768   void * jresult ;
47769   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47770   Dali::NinePatchImage::StretchRanges *result = 0 ;
47771
47772   arg1 = (Dali::NinePatchImage *)jarg1;
47773   {
47774     try {
47775       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47776     } catch (std::out_of_range& e) {
47777       {
47778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47779       };
47780     } catch (std::exception& e) {
47781       {
47782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47783       };
47784     } catch (Dali::DaliException e) {
47785       {
47786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47787       };
47788     } catch (...) {
47789       {
47790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47791       };
47792     }
47793   }
47794
47795   jresult = (void *)result;
47796   return jresult;
47797 }
47798
47799
47800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47801   void * jresult ;
47802   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47803   Dali::Rect< int > result;
47804
47805   arg1 = (Dali::NinePatchImage *)jarg1;
47806   {
47807     try {
47808       result = (arg1)->GetChildRectangle();
47809     } catch (std::out_of_range& e) {
47810       {
47811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47812       };
47813     } catch (std::exception& e) {
47814       {
47815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47816       };
47817     } catch (Dali::DaliException e) {
47818       {
47819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47824       };
47825     }
47826   }
47827
47828   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47829   return jresult;
47830 }
47831
47832
47833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47834   void * jresult ;
47835   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47836   Dali::BufferImage result;
47837
47838   arg1 = (Dali::NinePatchImage *)jarg1;
47839   {
47840     try {
47841       result = (arg1)->CreateCroppedBufferImage();
47842     } catch (std::out_of_range& e) {
47843       {
47844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47845       };
47846     } catch (std::exception& e) {
47847       {
47848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47849       };
47850     } catch (Dali::DaliException e) {
47851       {
47852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47853       };
47854     } catch (...) {
47855       {
47856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47857       };
47858     }
47859   }
47860
47861   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47862   return jresult;
47863 }
47864
47865
47866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47867   unsigned int jresult ;
47868   std::string *arg1 = 0 ;
47869   bool result;
47870
47871   if (!jarg1) {
47872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47873     return 0;
47874   }
47875   std::string arg1_str(jarg1);
47876   arg1 = &arg1_str;
47877   {
47878     try {
47879       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47880     } catch (std::out_of_range& e) {
47881       {
47882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47883       };
47884     } catch (std::exception& e) {
47885       {
47886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47887       };
47888     } catch (Dali::DaliException e) {
47889       {
47890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47891       };
47892     } catch (...) {
47893       {
47894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47895       };
47896     }
47897   }
47898
47899   jresult = result;
47900
47901   //argout typemap for const std::string&
47902
47903   return jresult;
47904 }
47905
47906
47907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47908   int jresult ;
47909   int result;
47910
47911   result = (int)Dali::CameraActor::Property::TYPE;
47912   jresult = (int)result;
47913   return jresult;
47914 }
47915
47916
47917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47918   int jresult ;
47919   int result;
47920
47921   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47922   jresult = (int)result;
47923   return jresult;
47924 }
47925
47926
47927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47928   int jresult ;
47929   int result;
47930
47931   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47932   jresult = (int)result;
47933   return jresult;
47934 }
47935
47936
47937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47938   int jresult ;
47939   int result;
47940
47941   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47942   jresult = (int)result;
47943   return jresult;
47944 }
47945
47946
47947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47948   int jresult ;
47949   int result;
47950
47951   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47952   jresult = (int)result;
47953   return jresult;
47954 }
47955
47956
47957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47958   int jresult ;
47959   int result;
47960
47961   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47962   jresult = (int)result;
47963   return jresult;
47964 }
47965
47966
47967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47968   int jresult ;
47969   int result;
47970
47971   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47972   jresult = (int)result;
47973   return jresult;
47974 }
47975
47976
47977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47978   int jresult ;
47979   int result;
47980
47981   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47982   jresult = (int)result;
47983   return jresult;
47984 }
47985
47986
47987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47988   int jresult ;
47989   int result;
47990
47991   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47992   jresult = (int)result;
47993   return jresult;
47994 }
47995
47996
47997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47998   int jresult ;
47999   int result;
48000
48001   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48002   jresult = (int)result;
48003   return jresult;
48004 }
48005
48006
48007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48008   int jresult ;
48009   int result;
48010
48011   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48012   jresult = (int)result;
48013   return jresult;
48014 }
48015
48016
48017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48018   int jresult ;
48019   int result;
48020
48021   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48022   jresult = (int)result;
48023   return jresult;
48024 }
48025
48026
48027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48028   int jresult ;
48029   int result;
48030
48031   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48032   jresult = (int)result;
48033   return jresult;
48034 }
48035
48036
48037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48038   int jresult ;
48039   int result;
48040
48041   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48042   jresult = (int)result;
48043   return jresult;
48044 }
48045
48046
48047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48048   void * jresult ;
48049   Dali::CameraActor::Property *result = 0 ;
48050
48051   {
48052     try {
48053       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48054     } catch (std::out_of_range& e) {
48055       {
48056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48057       };
48058     } catch (std::exception& e) {
48059       {
48060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48061       };
48062     } catch (Dali::DaliException e) {
48063       {
48064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48065       };
48066     } catch (...) {
48067       {
48068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48069       };
48070     }
48071   }
48072
48073   jresult = (void *)result;
48074   return jresult;
48075 }
48076
48077
48078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48079   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48080
48081   arg1 = (Dali::CameraActor::Property *)jarg1;
48082   {
48083     try {
48084       delete arg1;
48085     } catch (std::out_of_range& e) {
48086       {
48087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48088       };
48089     } catch (std::exception& e) {
48090       {
48091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48092       };
48093     } catch (Dali::DaliException e) {
48094       {
48095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48096       };
48097     } catch (...) {
48098       {
48099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48100       };
48101     }
48102   }
48103
48104 }
48105
48106
48107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48108   void * jresult ;
48109   Dali::CameraActor *result = 0 ;
48110
48111   {
48112     try {
48113       result = (Dali::CameraActor *)new Dali::CameraActor();
48114     } catch (std::out_of_range& e) {
48115       {
48116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48117       };
48118     } catch (std::exception& e) {
48119       {
48120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48121       };
48122     } catch (Dali::DaliException e) {
48123       {
48124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48125       };
48126     } catch (...) {
48127       {
48128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48129       };
48130     }
48131   }
48132
48133   jresult = (void *)result;
48134   return jresult;
48135 }
48136
48137
48138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48139   void * jresult ;
48140   Dali::CameraActor result;
48141
48142   {
48143     try {
48144       result = Dali::CameraActor::New();
48145     } catch (std::out_of_range& e) {
48146       {
48147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48148       };
48149     } catch (std::exception& e) {
48150       {
48151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48152       };
48153     } catch (Dali::DaliException e) {
48154       {
48155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48156       };
48157     } catch (...) {
48158       {
48159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48160       };
48161     }
48162   }
48163
48164   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48165   return jresult;
48166 }
48167
48168
48169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48170   void * jresult ;
48171   Dali::Size *arg1 = 0 ;
48172   Dali::CameraActor result;
48173
48174   arg1 = (Dali::Size *)jarg1;
48175   if (!arg1) {
48176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48177     return 0;
48178   }
48179   {
48180     try {
48181       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48182     } catch (std::out_of_range& e) {
48183       {
48184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48185       };
48186     } catch (std::exception& e) {
48187       {
48188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48189       };
48190     } catch (Dali::DaliException e) {
48191       {
48192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48193       };
48194     } catch (...) {
48195       {
48196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48197       };
48198     }
48199   }
48200
48201   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48202   return jresult;
48203 }
48204
48205
48206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48207   void * jresult ;
48208   Dali::BaseHandle arg1 ;
48209   Dali::BaseHandle *argp1 ;
48210   Dali::CameraActor result;
48211
48212   argp1 = (Dali::BaseHandle *)jarg1;
48213   if (!argp1) {
48214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48215     return 0;
48216   }
48217   arg1 = *argp1;
48218   {
48219     try {
48220       result = Dali::CameraActor::DownCast(arg1);
48221     } catch (std::out_of_range& e) {
48222       {
48223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48224       };
48225     } catch (std::exception& e) {
48226       {
48227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48228       };
48229     } catch (Dali::DaliException e) {
48230       {
48231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48232       };
48233     } catch (...) {
48234       {
48235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48236       };
48237     }
48238   }
48239
48240   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48241   return jresult;
48242 }
48243
48244
48245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48246   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48247
48248   arg1 = (Dali::CameraActor *)jarg1;
48249   {
48250     try {
48251       delete arg1;
48252     } catch (std::out_of_range& e) {
48253       {
48254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48255       };
48256     } catch (std::exception& e) {
48257       {
48258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48259       };
48260     } catch (Dali::DaliException e) {
48261       {
48262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48263       };
48264     } catch (...) {
48265       {
48266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48267       };
48268     }
48269   }
48270
48271 }
48272
48273
48274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48275   void * jresult ;
48276   Dali::CameraActor *arg1 = 0 ;
48277   Dali::CameraActor *result = 0 ;
48278
48279   arg1 = (Dali::CameraActor *)jarg1;
48280   if (!arg1) {
48281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48282     return 0;
48283   }
48284   {
48285     try {
48286       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48287     } catch (std::out_of_range& e) {
48288       {
48289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48290       };
48291     } catch (std::exception& e) {
48292       {
48293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48294       };
48295     } catch (Dali::DaliException e) {
48296       {
48297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48298       };
48299     } catch (...) {
48300       {
48301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48302       };
48303     }
48304   }
48305
48306   jresult = (void *)result;
48307   return jresult;
48308 }
48309
48310
48311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48312   void * jresult ;
48313   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48314   Dali::CameraActor *arg2 = 0 ;
48315   Dali::CameraActor *result = 0 ;
48316
48317   arg1 = (Dali::CameraActor *)jarg1;
48318   arg2 = (Dali::CameraActor *)jarg2;
48319   if (!arg2) {
48320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48321     return 0;
48322   }
48323   {
48324     try {
48325       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48326     } catch (std::out_of_range& e) {
48327       {
48328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48329       };
48330     } catch (std::exception& e) {
48331       {
48332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48333       };
48334     } catch (Dali::DaliException e) {
48335       {
48336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48337       };
48338     } catch (...) {
48339       {
48340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48341       };
48342     }
48343   }
48344
48345   jresult = (void *)result;
48346   return jresult;
48347 }
48348
48349
48350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48351   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48352   Dali::Camera::Type arg2 ;
48353
48354   arg1 = (Dali::CameraActor *)jarg1;
48355   arg2 = (Dali::Camera::Type)jarg2;
48356   {
48357     try {
48358       (arg1)->SetType(arg2);
48359     } catch (std::out_of_range& e) {
48360       {
48361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48362       };
48363     } catch (std::exception& e) {
48364       {
48365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48366       };
48367     } catch (Dali::DaliException e) {
48368       {
48369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48370       };
48371     } catch (...) {
48372       {
48373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48374       };
48375     }
48376   }
48377
48378 }
48379
48380
48381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48382   int jresult ;
48383   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48384   Dali::Camera::Type result;
48385
48386   arg1 = (Dali::CameraActor *)jarg1;
48387   {
48388     try {
48389       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48390     } catch (std::out_of_range& e) {
48391       {
48392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48393       };
48394     } catch (std::exception& e) {
48395       {
48396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48397       };
48398     } catch (Dali::DaliException e) {
48399       {
48400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48401       };
48402     } catch (...) {
48403       {
48404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48405       };
48406     }
48407   }
48408
48409   jresult = (int)result;
48410   return jresult;
48411 }
48412
48413
48414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48415   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48416   Dali::Camera::ProjectionMode arg2 ;
48417
48418   arg1 = (Dali::CameraActor *)jarg1;
48419   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48420   {
48421     try {
48422       (arg1)->SetProjectionMode(arg2);
48423     } catch (std::out_of_range& e) {
48424       {
48425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48426       };
48427     } catch (std::exception& e) {
48428       {
48429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48430       };
48431     } catch (Dali::DaliException e) {
48432       {
48433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48434       };
48435     } catch (...) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48438       };
48439     }
48440   }
48441
48442 }
48443
48444
48445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48446   int jresult ;
48447   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48448   Dali::Camera::ProjectionMode result;
48449
48450   arg1 = (Dali::CameraActor *)jarg1;
48451   {
48452     try {
48453       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48454     } catch (std::out_of_range& e) {
48455       {
48456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48457       };
48458     } catch (std::exception& e) {
48459       {
48460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48461       };
48462     } catch (Dali::DaliException e) {
48463       {
48464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48465       };
48466     } catch (...) {
48467       {
48468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48469       };
48470     }
48471   }
48472
48473   jresult = (int)result;
48474   return jresult;
48475 }
48476
48477
48478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48479   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48480   float arg2 ;
48481
48482   arg1 = (Dali::CameraActor *)jarg1;
48483   arg2 = (float)jarg2;
48484   {
48485     try {
48486       (arg1)->SetFieldOfView(arg2);
48487     } catch (std::out_of_range& e) {
48488       {
48489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48490       };
48491     } catch (std::exception& e) {
48492       {
48493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48494       };
48495     } catch (Dali::DaliException e) {
48496       {
48497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48498       };
48499     } catch (...) {
48500       {
48501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48502       };
48503     }
48504   }
48505
48506 }
48507
48508
48509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48510   float jresult ;
48511   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48512   float result;
48513
48514   arg1 = (Dali::CameraActor *)jarg1;
48515   {
48516     try {
48517       result = (float)(arg1)->GetFieldOfView();
48518     } catch (std::out_of_range& e) {
48519       {
48520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48521       };
48522     } catch (std::exception& e) {
48523       {
48524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48525       };
48526     } catch (Dali::DaliException e) {
48527       {
48528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48529       };
48530     } catch (...) {
48531       {
48532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48533       };
48534     }
48535   }
48536
48537   jresult = result;
48538   return jresult;
48539 }
48540
48541
48542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48543   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48544   float arg2 ;
48545
48546   arg1 = (Dali::CameraActor *)jarg1;
48547   arg2 = (float)jarg2;
48548   {
48549     try {
48550       (arg1)->SetAspectRatio(arg2);
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (Dali::DaliException e) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48562       };
48563     } catch (...) {
48564       {
48565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48566       };
48567     }
48568   }
48569
48570 }
48571
48572
48573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48574   float jresult ;
48575   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48576   float result;
48577
48578   arg1 = (Dali::CameraActor *)jarg1;
48579   {
48580     try {
48581       result = (float)(arg1)->GetAspectRatio();
48582     } catch (std::out_of_range& e) {
48583       {
48584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48585       };
48586     } catch (std::exception& e) {
48587       {
48588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48589       };
48590     } catch (Dali::DaliException e) {
48591       {
48592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48593       };
48594     } catch (...) {
48595       {
48596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48597       };
48598     }
48599   }
48600
48601   jresult = result;
48602   return jresult;
48603 }
48604
48605
48606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48607   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48608   float arg2 ;
48609
48610   arg1 = (Dali::CameraActor *)jarg1;
48611   arg2 = (float)jarg2;
48612   {
48613     try {
48614       (arg1)->SetNearClippingPlane(arg2);
48615     } catch (std::out_of_range& e) {
48616       {
48617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48618       };
48619     } catch (std::exception& e) {
48620       {
48621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48622       };
48623     } catch (Dali::DaliException e) {
48624       {
48625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48626       };
48627     } catch (...) {
48628       {
48629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48630       };
48631     }
48632   }
48633
48634 }
48635
48636
48637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48638   float jresult ;
48639   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48640   float result;
48641
48642   arg1 = (Dali::CameraActor *)jarg1;
48643   {
48644     try {
48645       result = (float)(arg1)->GetNearClippingPlane();
48646     } catch (std::out_of_range& e) {
48647       {
48648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48649       };
48650     } catch (std::exception& e) {
48651       {
48652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48653       };
48654     } catch (Dali::DaliException e) {
48655       {
48656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48657       };
48658     } catch (...) {
48659       {
48660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48661       };
48662     }
48663   }
48664
48665   jresult = result;
48666   return jresult;
48667 }
48668
48669
48670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48671   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48672   float arg2 ;
48673
48674   arg1 = (Dali::CameraActor *)jarg1;
48675   arg2 = (float)jarg2;
48676   {
48677     try {
48678       (arg1)->SetFarClippingPlane(arg2);
48679     } catch (std::out_of_range& e) {
48680       {
48681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48682       };
48683     } catch (std::exception& e) {
48684       {
48685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48686       };
48687     } catch (Dali::DaliException e) {
48688       {
48689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48690       };
48691     } catch (...) {
48692       {
48693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48694       };
48695     }
48696   }
48697
48698 }
48699
48700
48701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48702   float jresult ;
48703   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48704   float result;
48705
48706   arg1 = (Dali::CameraActor *)jarg1;
48707   {
48708     try {
48709       result = (float)(arg1)->GetFarClippingPlane();
48710     } catch (std::out_of_range& e) {
48711       {
48712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48713       };
48714     } catch (std::exception& e) {
48715       {
48716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48717       };
48718     } catch (Dali::DaliException e) {
48719       {
48720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48721       };
48722     } catch (...) {
48723       {
48724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48725       };
48726     }
48727   }
48728
48729   jresult = result;
48730   return jresult;
48731 }
48732
48733
48734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48735   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48736   Dali::Vector3 *arg2 = 0 ;
48737
48738   arg1 = (Dali::CameraActor *)jarg1;
48739   arg2 = (Dali::Vector3 *)jarg2;
48740   if (!arg2) {
48741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48742     return ;
48743   }
48744   {
48745     try {
48746       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48747     } catch (std::out_of_range& e) {
48748       {
48749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48750       };
48751     } catch (std::exception& e) {
48752       {
48753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48754       };
48755     } catch (Dali::DaliException e) {
48756       {
48757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48758       };
48759     } catch (...) {
48760       {
48761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48762       };
48763     }
48764   }
48765
48766 }
48767
48768
48769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48770   void * jresult ;
48771   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48772   Dali::Vector3 result;
48773
48774   arg1 = (Dali::CameraActor *)jarg1;
48775   {
48776     try {
48777       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48778     } catch (std::out_of_range& e) {
48779       {
48780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48781       };
48782     } catch (std::exception& e) {
48783       {
48784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48785       };
48786     } catch (Dali::DaliException e) {
48787       {
48788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48789       };
48790     } catch (...) {
48791       {
48792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48793       };
48794     }
48795   }
48796
48797   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48798   return jresult;
48799 }
48800
48801
48802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48803   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48804   bool arg2 ;
48805
48806   arg1 = (Dali::CameraActor *)jarg1;
48807   arg2 = jarg2 ? true : false;
48808   {
48809     try {
48810       (arg1)->SetInvertYAxis(arg2);
48811     } catch (std::out_of_range& e) {
48812       {
48813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48814       };
48815     } catch (std::exception& e) {
48816       {
48817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48818       };
48819     } catch (Dali::DaliException e) {
48820       {
48821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48822       };
48823     } catch (...) {
48824       {
48825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48826       };
48827     }
48828   }
48829
48830 }
48831
48832
48833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48834   unsigned int jresult ;
48835   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48836   bool result;
48837
48838   arg1 = (Dali::CameraActor *)jarg1;
48839   {
48840     try {
48841       result = (bool)(arg1)->GetInvertYAxis();
48842     } catch (std::out_of_range& e) {
48843       {
48844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48845       };
48846     } catch (std::exception& e) {
48847       {
48848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48849       };
48850     } catch (Dali::DaliException e) {
48851       {
48852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48853       };
48854     } catch (...) {
48855       {
48856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48857       };
48858     }
48859   }
48860
48861   jresult = result;
48862   return jresult;
48863 }
48864
48865
48866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48867   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48868   Dali::Size *arg2 = 0 ;
48869
48870   arg1 = (Dali::CameraActor *)jarg1;
48871   arg2 = (Dali::Size *)jarg2;
48872   if (!arg2) {
48873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48874     return ;
48875   }
48876   {
48877     try {
48878       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48879     } catch (std::out_of_range& e) {
48880       {
48881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48882       };
48883     } catch (std::exception& e) {
48884       {
48885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48886       };
48887     } catch (Dali::DaliException e) {
48888       {
48889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48890       };
48891     } catch (...) {
48892       {
48893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48894       };
48895     }
48896   }
48897
48898 }
48899
48900
48901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48902   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48903   Dali::Size *arg2 = 0 ;
48904
48905   arg1 = (Dali::CameraActor *)jarg1;
48906   arg2 = (Dali::Size *)jarg2;
48907   if (!arg2) {
48908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48909     return ;
48910   }
48911   {
48912     try {
48913       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48914     } catch (std::out_of_range& e) {
48915       {
48916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48917       };
48918     } catch (std::exception& e) {
48919       {
48920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48921       };
48922     } catch (Dali::DaliException e) {
48923       {
48924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48925       };
48926     } catch (...) {
48927       {
48928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48929       };
48930     }
48931   }
48932
48933 }
48934
48935
48936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48937   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48938   float arg2 ;
48939   float arg3 ;
48940   float arg4 ;
48941   float arg5 ;
48942   float arg6 ;
48943   float arg7 ;
48944
48945   arg1 = (Dali::CameraActor *)jarg1;
48946   arg2 = (float)jarg2;
48947   arg3 = (float)jarg3;
48948   arg4 = (float)jarg4;
48949   arg5 = (float)jarg5;
48950   arg6 = (float)jarg6;
48951   arg7 = (float)jarg7;
48952   {
48953     try {
48954       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48955     } catch (std::out_of_range& e) {
48956       {
48957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48958       };
48959     } catch (std::exception& e) {
48960       {
48961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48962       };
48963     } catch (Dali::DaliException e) {
48964       {
48965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48966       };
48967     } catch (...) {
48968       {
48969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48970       };
48971     }
48972   }
48973
48974 }
48975
48976
48977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48978   void * jresult ;
48979   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48980
48981   {
48982     try {
48983       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48984     } catch (std::out_of_range& e) {
48985       {
48986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48987       };
48988     } catch (std::exception& e) {
48989       {
48990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48991       };
48992     } catch (Dali::DaliException e) {
48993       {
48994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48995       };
48996     } catch (...) {
48997       {
48998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48999       };
49000     }
49001   }
49002
49003   jresult = (void *)result;
49004   return jresult;
49005 }
49006
49007
49008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49009   void * jresult ;
49010   std::string arg1 ;
49011   Dali::Property::Value arg2 ;
49012   Dali::Property::Value *argp2 ;
49013   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49014
49015   if (!jarg1) {
49016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49017     return 0;
49018   }
49019   (&arg1)->assign(jarg1);
49020   argp2 = (Dali::Property::Value *)jarg2;
49021   if (!argp2) {
49022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49023     return 0;
49024   }
49025   arg2 = *argp2;
49026   {
49027     try {
49028       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49029     } catch (std::out_of_range& e) {
49030       {
49031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49032       };
49033     } catch (std::exception& e) {
49034       {
49035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49036       };
49037     } catch (Dali::DaliException e) {
49038       {
49039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49040       };
49041     } catch (...) {
49042       {
49043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49044       };
49045     }
49046   }
49047
49048   jresult = (void *)result;
49049   return jresult;
49050 }
49051
49052
49053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49054   void * jresult ;
49055   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49056   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49057
49058   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49059   if (!arg1) {
49060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49061     return 0;
49062   }
49063   {
49064     try {
49065       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);
49066     } catch (std::out_of_range& e) {
49067       {
49068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49069       };
49070     } catch (std::exception& e) {
49071       {
49072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49073       };
49074     } catch (Dali::DaliException e) {
49075       {
49076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49077       };
49078     } catch (...) {
49079       {
49080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49081       };
49082     }
49083   }
49084
49085   jresult = (void *)result;
49086   return jresult;
49087 }
49088
49089
49090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49091   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49092   std::string *arg2 = 0 ;
49093
49094   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49095   if (!jarg2) {
49096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49097     return ;
49098   }
49099   std::string arg2_str(jarg2);
49100   arg2 = &arg2_str;
49101   if (arg1) (arg1)->first = *arg2;
49102
49103   //argout typemap for const std::string&
49104
49105 }
49106
49107
49108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49109   char * jresult ;
49110   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49111   std::string *result = 0 ;
49112
49113   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49114   result = (std::string *) & ((arg1)->first);
49115   jresult = SWIG_csharp_string_callback(result->c_str());
49116   return jresult;
49117 }
49118
49119
49120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49121   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49122   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49123
49124   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49125   arg2 = (Dali::Property::Value *)jarg2;
49126   if (arg1) (arg1)->second = *arg2;
49127 }
49128
49129
49130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49131   void * jresult ;
49132   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49133   Dali::Property::Value *result = 0 ;
49134
49135   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49136   result = (Dali::Property::Value *)& ((arg1)->second);
49137   jresult = (void *)result;
49138   return jresult;
49139 }
49140
49141
49142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49143   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49144
49145   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49146   {
49147     try {
49148       delete arg1;
49149     } catch (std::out_of_range& e) {
49150       {
49151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49152       };
49153     } catch (std::exception& e) {
49154       {
49155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49156       };
49157     } catch (Dali::DaliException e) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49160       };
49161     } catch (...) {
49162       {
49163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49164       };
49165     }
49166   }
49167
49168 }
49169
49170
49171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49172   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49173
49174   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49175   {
49176     try {
49177       (arg1)->clear();
49178     } catch (std::out_of_range& e) {
49179       {
49180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49181       };
49182     } catch (std::exception& e) {
49183       {
49184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49185       };
49186     } catch (Dali::DaliException e) {
49187       {
49188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49189       };
49190     } catch (...) {
49191       {
49192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49193       };
49194     }
49195   }
49196
49197 }
49198
49199
49200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49201   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49202   Dali::TouchPoint *arg2 = 0 ;
49203
49204   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49205   arg2 = (Dali::TouchPoint *)jarg2;
49206   if (!arg2) {
49207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49208     return ;
49209   }
49210   {
49211     try {
49212       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49213     } catch (std::out_of_range& e) {
49214       {
49215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (std::exception& e) {
49218       {
49219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49220       };
49221     } catch (Dali::DaliException e) {
49222       {
49223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49224       };
49225     } catch (...) {
49226       {
49227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49228       };
49229     }
49230   }
49231
49232 }
49233
49234
49235 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49236   unsigned long jresult ;
49237   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49238   std::vector< Dali::TouchPoint >::size_type result;
49239
49240   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49241   {
49242     try {
49243       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49244     } catch (std::out_of_range& e) {
49245       {
49246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49247       };
49248     } catch (std::exception& e) {
49249       {
49250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49251       };
49252     } catch (Dali::DaliException e) {
49253       {
49254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49255       };
49256     } catch (...) {
49257       {
49258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49259       };
49260     }
49261   }
49262
49263   jresult = (unsigned long)result;
49264   return jresult;
49265 }
49266
49267
49268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49269   unsigned long jresult ;
49270   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49271   std::vector< Dali::TouchPoint >::size_type result;
49272
49273   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49274   {
49275     try {
49276       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49277     } catch (std::out_of_range& e) {
49278       {
49279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49280       };
49281     } catch (std::exception& e) {
49282       {
49283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49284       };
49285     } catch (Dali::DaliException e) {
49286       {
49287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49288       };
49289     } catch (...) {
49290       {
49291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49292       };
49293     }
49294   }
49295
49296   jresult = (unsigned long)result;
49297   return jresult;
49298 }
49299
49300
49301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49302   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49303   std::vector< Dali::TouchPoint >::size_type arg2 ;
49304
49305   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49306   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49307   {
49308     try {
49309       (arg1)->reserve(arg2);
49310     } catch (std::out_of_range& e) {
49311       {
49312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49313       };
49314     } catch (std::exception& e) {
49315       {
49316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49317       };
49318     } catch (Dali::DaliException e) {
49319       {
49320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49321       };
49322     } catch (...) {
49323       {
49324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49325       };
49326     }
49327   }
49328
49329 }
49330
49331
49332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49333   void * jresult ;
49334   std::vector< Dali::TouchPoint > *result = 0 ;
49335
49336   {
49337     try {
49338       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49339     } catch (std::out_of_range& e) {
49340       {
49341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49342       };
49343     } catch (std::exception& e) {
49344       {
49345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49346       };
49347     } catch (Dali::DaliException e) {
49348       {
49349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49350       };
49351     } catch (...) {
49352       {
49353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49354       };
49355     }
49356   }
49357
49358   jresult = (void *)result;
49359   return jresult;
49360 }
49361
49362
49363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49364   void * jresult ;
49365   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49366   std::vector< Dali::TouchPoint > *result = 0 ;
49367
49368   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49369   if (!arg1) {
49370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49371     return 0;
49372   }
49373   {
49374     try {
49375       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49376     } catch (std::out_of_range& e) {
49377       {
49378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49379       };
49380     } catch (std::exception& e) {
49381       {
49382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49383       };
49384     } catch (Dali::DaliException e) {
49385       {
49386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49387       };
49388     } catch (...) {
49389       {
49390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49391       };
49392     }
49393   }
49394
49395   jresult = (void *)result;
49396   return jresult;
49397 }
49398
49399
49400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49401   void * jresult ;
49402   int arg1 ;
49403   std::vector< Dali::TouchPoint > *result = 0 ;
49404
49405   arg1 = (int)jarg1;
49406   {
49407     try {
49408       try {
49409         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49410       }
49411       catch(std::out_of_range &_e) {
49412         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49413         return 0;
49414       }
49415
49416     } catch (std::out_of_range& e) {
49417       {
49418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49419       };
49420     } catch (std::exception& e) {
49421       {
49422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49423       };
49424     } catch (Dali::DaliException e) {
49425       {
49426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49427       };
49428     } catch (...) {
49429       {
49430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49431       };
49432     }
49433   }
49434
49435   jresult = (void *)result;
49436   return jresult;
49437 }
49438
49439
49440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49441   void * jresult ;
49442   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49443   int arg2 ;
49444   SwigValueWrapper< Dali::TouchPoint > result;
49445
49446   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49447   arg2 = (int)jarg2;
49448   {
49449     try {
49450       try {
49451         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49452       }
49453       catch(std::out_of_range &_e) {
49454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49455         return 0;
49456       }
49457
49458     } catch (std::out_of_range& e) {
49459       {
49460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49461       };
49462     } catch (std::exception& e) {
49463       {
49464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49465       };
49466     } catch (Dali::DaliException e) {
49467       {
49468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49469       };
49470     } catch (...) {
49471       {
49472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49473       };
49474     }
49475   }
49476
49477   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49478   return jresult;
49479 }
49480
49481
49482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49483   void * jresult ;
49484   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49485   int arg2 ;
49486   Dali::TouchPoint *result = 0 ;
49487
49488   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49489   arg2 = (int)jarg2;
49490   {
49491     try {
49492       try {
49493         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49494       }
49495       catch(std::out_of_range &_e) {
49496         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49497         return 0;
49498       }
49499
49500     } catch (std::out_of_range& e) {
49501       {
49502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49503       };
49504     } catch (std::exception& e) {
49505       {
49506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49507       };
49508     } catch (Dali::DaliException e) {
49509       {
49510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49511       };
49512     } catch (...) {
49513       {
49514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49515       };
49516     }
49517   }
49518
49519   jresult = (void *)result;
49520   return jresult;
49521 }
49522
49523
49524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49525   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49526   int arg2 ;
49527   Dali::TouchPoint *arg3 = 0 ;
49528
49529   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49530   arg2 = (int)jarg2;
49531   arg3 = (Dali::TouchPoint *)jarg3;
49532   if (!arg3) {
49533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49534     return ;
49535   }
49536   {
49537     try {
49538       try {
49539         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49540       }
49541       catch(std::out_of_range &_e) {
49542         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49543         return ;
49544       }
49545
49546     } catch (std::out_of_range& e) {
49547       {
49548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49549       };
49550     } catch (std::exception& e) {
49551       {
49552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49553       };
49554     } catch (Dali::DaliException e) {
49555       {
49556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49557       };
49558     } catch (...) {
49559       {
49560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49561       };
49562     }
49563   }
49564
49565 }
49566
49567
49568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49569   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49570   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49571
49572   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49573   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49574   if (!arg2) {
49575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49576     return ;
49577   }
49578   {
49579     try {
49580       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49581     } catch (std::out_of_range& e) {
49582       {
49583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (std::exception& e) {
49586       {
49587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49588       };
49589     } catch (Dali::DaliException e) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49592       };
49593     } catch (...) {
49594       {
49595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49596       };
49597     }
49598   }
49599
49600 }
49601
49602
49603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49604   void * jresult ;
49605   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49606   int arg2 ;
49607   int arg3 ;
49608   std::vector< Dali::TouchPoint > *result = 0 ;
49609
49610   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49611   arg2 = (int)jarg2;
49612   arg3 = (int)jarg3;
49613   {
49614     try {
49615       try {
49616         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49617       }
49618       catch(std::out_of_range &_e) {
49619         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49620         return 0;
49621       }
49622       catch(std::invalid_argument &_e) {
49623         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49624         return 0;
49625       }
49626
49627     } catch (std::out_of_range& e) {
49628       {
49629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49630       };
49631     } catch (std::exception& e) {
49632       {
49633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49634       };
49635     } catch (Dali::DaliException e) {
49636       {
49637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49638       };
49639     } catch (...) {
49640       {
49641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49642       };
49643     }
49644   }
49645
49646   jresult = (void *)result;
49647   return jresult;
49648 }
49649
49650
49651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49652   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49653   int arg2 ;
49654   Dali::TouchPoint *arg3 = 0 ;
49655
49656   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49657   arg2 = (int)jarg2;
49658   arg3 = (Dali::TouchPoint *)jarg3;
49659   if (!arg3) {
49660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49661     return ;
49662   }
49663   {
49664     try {
49665       try {
49666         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49667       }
49668       catch(std::out_of_range &_e) {
49669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49670         return ;
49671       }
49672
49673     } catch (std::out_of_range& e) {
49674       {
49675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49676       };
49677     } catch (std::exception& e) {
49678       {
49679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (Dali::DaliException e) {
49682       {
49683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49684       };
49685     } catch (...) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49688       };
49689     }
49690   }
49691
49692 }
49693
49694
49695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49696   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49697   int arg2 ;
49698   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49699
49700   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49701   arg2 = (int)jarg2;
49702   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49703   if (!arg3) {
49704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49705     return ;
49706   }
49707   {
49708     try {
49709       try {
49710         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49711       }
49712       catch(std::out_of_range &_e) {
49713         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49714         return ;
49715       }
49716
49717     } catch (std::out_of_range& e) {
49718       {
49719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49720       };
49721     } catch (std::exception& e) {
49722       {
49723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49724       };
49725     } catch (Dali::DaliException e) {
49726       {
49727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49728       };
49729     } catch (...) {
49730       {
49731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49732       };
49733     }
49734   }
49735
49736 }
49737
49738
49739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49740   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49741   int arg2 ;
49742
49743   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49744   arg2 = (int)jarg2;
49745   {
49746     try {
49747       try {
49748         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49749       }
49750       catch(std::out_of_range &_e) {
49751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49752         return ;
49753       }
49754
49755     } catch (std::out_of_range& e) {
49756       {
49757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49758       };
49759     } catch (std::exception& e) {
49760       {
49761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (Dali::DaliException e) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49766       };
49767     } catch (...) {
49768       {
49769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49770       };
49771     }
49772   }
49773
49774 }
49775
49776
49777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49778   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49779   int arg2 ;
49780   int arg3 ;
49781
49782   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49783   arg2 = (int)jarg2;
49784   arg3 = (int)jarg3;
49785   {
49786     try {
49787       try {
49788         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49789       }
49790       catch(std::out_of_range &_e) {
49791         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49792         return ;
49793       }
49794       catch(std::invalid_argument &_e) {
49795         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49796         return ;
49797       }
49798
49799     } catch (std::out_of_range& e) {
49800       {
49801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49802       };
49803     } catch (std::exception& e) {
49804       {
49805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49806       };
49807     } catch (Dali::DaliException e) {
49808       {
49809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49810       };
49811     } catch (...) {
49812       {
49813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49814       };
49815     }
49816   }
49817
49818 }
49819
49820
49821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49822   void * jresult ;
49823   Dali::TouchPoint *arg1 = 0 ;
49824   int arg2 ;
49825   std::vector< Dali::TouchPoint > *result = 0 ;
49826
49827   arg1 = (Dali::TouchPoint *)jarg1;
49828   if (!arg1) {
49829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49830     return 0;
49831   }
49832   arg2 = (int)jarg2;
49833   {
49834     try {
49835       try {
49836         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49837       }
49838       catch(std::out_of_range &_e) {
49839         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49840         return 0;
49841       }
49842
49843     } catch (std::out_of_range& e) {
49844       {
49845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49846       };
49847     } catch (std::exception& e) {
49848       {
49849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49850       };
49851     } catch (Dali::DaliException e) {
49852       {
49853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49854       };
49855     } catch (...) {
49856       {
49857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49858       };
49859     }
49860   }
49861
49862   jresult = (void *)result;
49863   return jresult;
49864 }
49865
49866
49867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49868   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49869
49870   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49871   {
49872     try {
49873       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49874     } catch (std::out_of_range& e) {
49875       {
49876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49877       };
49878     } catch (std::exception& e) {
49879       {
49880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49881       };
49882     } catch (Dali::DaliException e) {
49883       {
49884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49885       };
49886     } catch (...) {
49887       {
49888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49889       };
49890     }
49891   }
49892
49893 }
49894
49895
49896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49897   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49898   int arg2 ;
49899   int arg3 ;
49900
49901   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49902   arg2 = (int)jarg2;
49903   arg3 = (int)jarg3;
49904   {
49905     try {
49906       try {
49907         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49908       }
49909       catch(std::out_of_range &_e) {
49910         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49911         return ;
49912       }
49913       catch(std::invalid_argument &_e) {
49914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49915         return ;
49916       }
49917
49918     } catch (std::out_of_range& e) {
49919       {
49920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (std::exception& e) {
49923       {
49924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49925       };
49926     } catch (Dali::DaliException e) {
49927       {
49928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49929       };
49930     } catch (...) {
49931       {
49932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49933       };
49934     }
49935   }
49936
49937 }
49938
49939
49940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49941   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49942   int arg2 ;
49943   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49944
49945   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49946   arg2 = (int)jarg2;
49947   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49948   if (!arg3) {
49949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49950     return ;
49951   }
49952   {
49953     try {
49954       try {
49955         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49956       }
49957       catch(std::out_of_range &_e) {
49958         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49959         return ;
49960       }
49961
49962     } catch (std::out_of_range& e) {
49963       {
49964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (std::exception& e) {
49967       {
49968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49969       };
49970     } catch (Dali::DaliException e) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49973       };
49974     } catch (...) {
49975       {
49976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49977       };
49978     }
49979   }
49980
49981 }
49982
49983
49984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49985   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49986
49987   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49988   {
49989     try {
49990       delete arg1;
49991     } catch (std::out_of_range& e) {
49992       {
49993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49994       };
49995     } catch (std::exception& e) {
49996       {
49997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49998       };
49999     } catch (Dali::DaliException e) {
50000       {
50001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50002       };
50003     } catch (...) {
50004       {
50005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50006       };
50007     }
50008   }
50009
50010 }
50011
50012
50013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50014   void * jresult ;
50015   Dali::Rect< int > *result = 0 ;
50016
50017   {
50018     try {
50019       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50020     } catch (std::out_of_range& e) {
50021       {
50022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50023       };
50024     } catch (std::exception& e) {
50025       {
50026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50027       };
50028     } catch (Dali::DaliException e) {
50029       {
50030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50031       };
50032     } catch (...) {
50033       {
50034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50035       };
50036     }
50037   }
50038
50039   jresult = (void *)result;
50040   return jresult;
50041 }
50042
50043
50044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50045   void * jresult ;
50046   int arg1 ;
50047   int arg2 ;
50048   int arg3 ;
50049   int arg4 ;
50050   Dali::Rect< int > *result = 0 ;
50051
50052   arg1 = (int)jarg1;
50053   arg2 = (int)jarg2;
50054   arg3 = (int)jarg3;
50055   arg4 = (int)jarg4;
50056   {
50057     try {
50058       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50059     } catch (std::out_of_range& e) {
50060       {
50061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50062       };
50063     } catch (std::exception& e) {
50064       {
50065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50066       };
50067     } catch (Dali::DaliException e) {
50068       {
50069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50070       };
50071     } catch (...) {
50072       {
50073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50074       };
50075     }
50076   }
50077
50078   jresult = (void *)result;
50079   return jresult;
50080 }
50081
50082
50083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50084   void * jresult ;
50085   Dali::Rect< int > *arg1 = 0 ;
50086   Dali::Rect< int > *result = 0 ;
50087
50088   arg1 = (Dali::Rect< int > *)jarg1;
50089   if (!arg1) {
50090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50091     return 0;
50092   }
50093   {
50094     try {
50095       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50096     } catch (std::out_of_range& e) {
50097       {
50098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50099       };
50100     } catch (std::exception& e) {
50101       {
50102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50103       };
50104     } catch (Dali::DaliException e) {
50105       {
50106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50107       };
50108     } catch (...) {
50109       {
50110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50111       };
50112     }
50113   }
50114
50115   jresult = (void *)result;
50116   return jresult;
50117 }
50118
50119
50120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50121   void * jresult ;
50122   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50123   Dali::Rect< int > *arg2 = 0 ;
50124   Dali::Rect< int > *result = 0 ;
50125
50126   arg1 = (Dali::Rect< int > *)jarg1;
50127   arg2 = (Dali::Rect< int > *)jarg2;
50128   if (!arg2) {
50129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50130     return 0;
50131   }
50132   {
50133     try {
50134       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50135     } catch (std::out_of_range& e) {
50136       {
50137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50138       };
50139     } catch (std::exception& e) {
50140       {
50141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50142       };
50143     } catch (Dali::DaliException e) {
50144       {
50145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50146       };
50147     } catch (...) {
50148       {
50149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50150       };
50151     }
50152   }
50153
50154   jresult = (void *)result;
50155   return jresult;
50156 }
50157
50158
50159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50160   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50161   int arg2 ;
50162   int arg3 ;
50163   int arg4 ;
50164   int arg5 ;
50165
50166   arg1 = (Dali::Rect< int > *)jarg1;
50167   arg2 = (int)jarg2;
50168   arg3 = (int)jarg3;
50169   arg4 = (int)jarg4;
50170   arg5 = (int)jarg5;
50171   {
50172     try {
50173       (arg1)->Set(arg2,arg3,arg4,arg5);
50174     } catch (std::out_of_range& e) {
50175       {
50176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50177       };
50178     } catch (std::exception& e) {
50179       {
50180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50181       };
50182     } catch (Dali::DaliException e) {
50183       {
50184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50185       };
50186     } catch (...) {
50187       {
50188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50189       };
50190     }
50191   }
50192
50193 }
50194
50195
50196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50197   unsigned int jresult ;
50198   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50199   bool result;
50200
50201   arg1 = (Dali::Rect< int > *)jarg1;
50202   {
50203     try {
50204       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50205     } catch (std::out_of_range& e) {
50206       {
50207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50208       };
50209     } catch (std::exception& e) {
50210       {
50211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50212       };
50213     } catch (Dali::DaliException e) {
50214       {
50215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50216       };
50217     } catch (...) {
50218       {
50219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50220       };
50221     }
50222   }
50223
50224   jresult = result;
50225   return jresult;
50226 }
50227
50228
50229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50230   int jresult ;
50231   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50232   int result;
50233
50234   arg1 = (Dali::Rect< int > *)jarg1;
50235   {
50236     try {
50237       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50238     } catch (std::out_of_range& e) {
50239       {
50240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50241       };
50242     } catch (std::exception& e) {
50243       {
50244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50245       };
50246     } catch (Dali::DaliException e) {
50247       {
50248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50249       };
50250     } catch (...) {
50251       {
50252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50253       };
50254     }
50255   }
50256
50257   jresult = result;
50258   return jresult;
50259 }
50260
50261
50262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50263   int jresult ;
50264   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50265   int result;
50266
50267   arg1 = (Dali::Rect< int > *)jarg1;
50268   {
50269     try {
50270       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50271     } catch (std::out_of_range& e) {
50272       {
50273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50274       };
50275     } catch (std::exception& e) {
50276       {
50277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50278       };
50279     } catch (Dali::DaliException e) {
50280       {
50281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50282       };
50283     } catch (...) {
50284       {
50285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50286       };
50287     }
50288   }
50289
50290   jresult = result;
50291   return jresult;
50292 }
50293
50294
50295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50296   int jresult ;
50297   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50298   int result;
50299
50300   arg1 = (Dali::Rect< int > *)jarg1;
50301   {
50302     try {
50303       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50304     } catch (std::out_of_range& e) {
50305       {
50306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50307       };
50308     } catch (std::exception& e) {
50309       {
50310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50311       };
50312     } catch (Dali::DaliException e) {
50313       {
50314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50315       };
50316     } catch (...) {
50317       {
50318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50319       };
50320     }
50321   }
50322
50323   jresult = result;
50324   return jresult;
50325 }
50326
50327
50328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50329   int jresult ;
50330   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50331   int result;
50332
50333   arg1 = (Dali::Rect< int > *)jarg1;
50334   {
50335     try {
50336       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50337     } catch (std::out_of_range& e) {
50338       {
50339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50340       };
50341     } catch (std::exception& e) {
50342       {
50343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50344       };
50345     } catch (Dali::DaliException e) {
50346       {
50347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50352       };
50353     }
50354   }
50355
50356   jresult = result;
50357   return jresult;
50358 }
50359
50360
50361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50362   int jresult ;
50363   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50364   int result;
50365
50366   arg1 = (Dali::Rect< int > *)jarg1;
50367   {
50368     try {
50369       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50370     } catch (std::out_of_range& e) {
50371       {
50372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50373       };
50374     } catch (std::exception& e) {
50375       {
50376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50377       };
50378     } catch (Dali::DaliException e) {
50379       {
50380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50381       };
50382     } catch (...) {
50383       {
50384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50385       };
50386     }
50387   }
50388
50389   jresult = result;
50390   return jresult;
50391 }
50392
50393
50394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50395   unsigned int jresult ;
50396   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50397   Dali::Rect< int > *arg2 = 0 ;
50398   bool result;
50399
50400   arg1 = (Dali::Rect< int > *)jarg1;
50401   arg2 = (Dali::Rect< int > *)jarg2;
50402   if (!arg2) {
50403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50404     return 0;
50405   }
50406   {
50407     try {
50408       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50409     } catch (std::out_of_range& e) {
50410       {
50411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50412       };
50413     } catch (std::exception& e) {
50414       {
50415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50416       };
50417     } catch (Dali::DaliException e) {
50418       {
50419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50420       };
50421     } catch (...) {
50422       {
50423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50424       };
50425     }
50426   }
50427
50428   jresult = result;
50429   return jresult;
50430 }
50431
50432
50433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50434   unsigned int jresult ;
50435   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50436   Dali::Rect< int > *arg2 = 0 ;
50437   bool result;
50438
50439   arg1 = (Dali::Rect< int > *)jarg1;
50440   arg2 = (Dali::Rect< int > *)jarg2;
50441   if (!arg2) {
50442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50443     return 0;
50444   }
50445   {
50446     try {
50447       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50448     } catch (std::out_of_range& e) {
50449       {
50450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50451       };
50452     } catch (std::exception& e) {
50453       {
50454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50455       };
50456     } catch (Dali::DaliException e) {
50457       {
50458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50459       };
50460     } catch (...) {
50461       {
50462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50463       };
50464     }
50465   }
50466
50467   jresult = result;
50468   return jresult;
50469 }
50470
50471
50472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50473   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50474   int arg2 ;
50475
50476   arg1 = (Dali::Rect< int > *)jarg1;
50477   arg2 = (int)jarg2;
50478   if (arg1) (arg1)->x = arg2;
50479 }
50480
50481
50482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50483   int jresult ;
50484   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50485   int result;
50486
50487   arg1 = (Dali::Rect< int > *)jarg1;
50488   result = (int) ((arg1)->x);
50489   jresult = result;
50490   return jresult;
50491 }
50492
50493
50494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50495   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50496   int arg2 ;
50497
50498   arg1 = (Dali::Rect< int > *)jarg1;
50499   arg2 = (int)jarg2;
50500   if (arg1) (arg1)->left = arg2;
50501 }
50502
50503
50504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50505   int jresult ;
50506   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50507   int result;
50508
50509   arg1 = (Dali::Rect< int > *)jarg1;
50510   result = (int) ((arg1)->left);
50511   jresult = result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50517   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50518   int arg2 ;
50519
50520   arg1 = (Dali::Rect< int > *)jarg1;
50521   arg2 = (int)jarg2;
50522   if (arg1) (arg1)->y = arg2;
50523 }
50524
50525
50526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50527   int jresult ;
50528   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50529   int result;
50530
50531   arg1 = (Dali::Rect< int > *)jarg1;
50532   result = (int) ((arg1)->y);
50533   jresult = result;
50534   return jresult;
50535 }
50536
50537
50538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50539   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50540   int arg2 ;
50541
50542   arg1 = (Dali::Rect< int > *)jarg1;
50543   arg2 = (int)jarg2;
50544   if (arg1) (arg1)->right = arg2;
50545 }
50546
50547
50548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50549   int jresult ;
50550   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50551   int result;
50552
50553   arg1 = (Dali::Rect< int > *)jarg1;
50554   result = (int) ((arg1)->right);
50555   jresult = result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50561   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50562   int arg2 ;
50563
50564   arg1 = (Dali::Rect< int > *)jarg1;
50565   arg2 = (int)jarg2;
50566   if (arg1) (arg1)->width = arg2;
50567 }
50568
50569
50570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50571   int jresult ;
50572   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50573   int result;
50574
50575   arg1 = (Dali::Rect< int > *)jarg1;
50576   result = (int) ((arg1)->width);
50577   jresult = result;
50578   return jresult;
50579 }
50580
50581
50582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50583   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50584   int arg2 ;
50585
50586   arg1 = (Dali::Rect< int > *)jarg1;
50587   arg2 = (int)jarg2;
50588   if (arg1) (arg1)->bottom = arg2;
50589 }
50590
50591
50592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50593   int jresult ;
50594   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50595   int result;
50596
50597   arg1 = (Dali::Rect< int > *)jarg1;
50598   result = (int) ((arg1)->bottom);
50599   jresult = result;
50600   return jresult;
50601 }
50602
50603
50604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50605   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50606   int arg2 ;
50607
50608   arg1 = (Dali::Rect< int > *)jarg1;
50609   arg2 = (int)jarg2;
50610   if (arg1) (arg1)->height = arg2;
50611 }
50612
50613
50614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50615   int jresult ;
50616   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50617   int result;
50618
50619   arg1 = (Dali::Rect< int > *)jarg1;
50620   result = (int) ((arg1)->height);
50621   jresult = result;
50622   return jresult;
50623 }
50624
50625
50626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50627   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50628   int arg2 ;
50629
50630   arg1 = (Dali::Rect< int > *)jarg1;
50631   arg2 = (int)jarg2;
50632   if (arg1) (arg1)->top = arg2;
50633 }
50634
50635
50636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50637   int jresult ;
50638   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50639   int result;
50640
50641   arg1 = (Dali::Rect< int > *)jarg1;
50642   result = (int) ((arg1)->top);
50643   jresult = result;
50644   return jresult;
50645 }
50646
50647
50648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50649   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50650
50651   arg1 = (Dali::Rect< int > *)jarg1;
50652   {
50653     try {
50654       delete arg1;
50655     } catch (std::out_of_range& e) {
50656       {
50657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50658       };
50659     } catch (std::exception& e) {
50660       {
50661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50662       };
50663     } catch (Dali::DaliException e) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50666       };
50667     } catch (...) {
50668       {
50669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50670       };
50671     }
50672   }
50673
50674 }
50675
50676
50677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50678   void * jresult ;
50679   Dali::Rect< float > *result = 0 ;
50680
50681   {
50682     try {
50683       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50684     } catch (std::out_of_range& e) {
50685       {
50686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50687       };
50688     } catch (std::exception& e) {
50689       {
50690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50691       };
50692     } catch (Dali::DaliException e) {
50693       {
50694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50695       };
50696     } catch (...) {
50697       {
50698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50699       };
50700     }
50701   }
50702
50703   jresult = (void *)result;
50704   return jresult;
50705 }
50706
50707
50708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50709   void * jresult ;
50710   float arg1 ;
50711   float arg2 ;
50712   float arg3 ;
50713   float arg4 ;
50714   Dali::Rect< float > *result = 0 ;
50715
50716   arg1 = (float)jarg1;
50717   arg2 = (float)jarg2;
50718   arg3 = (float)jarg4;
50719   arg4 = (float)jarg3;
50720   {
50721     try {
50722       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50723     } catch (std::out_of_range& e) {
50724       {
50725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50726       };
50727     } catch (std::exception& e) {
50728       {
50729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50730       };
50731     } catch (Dali::DaliException e) {
50732       {
50733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50734       };
50735     } catch (...) {
50736       {
50737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50738       };
50739     }
50740   }
50741
50742   jresult = (void *)result;
50743   return jresult;
50744 }
50745
50746
50747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50748   void * jresult ;
50749   Dali::Rect< float > *arg1 = 0 ;
50750   Dali::Rect< float > *result = 0 ;
50751
50752   arg1 = (Dali::Rect< float > *)jarg1;
50753   if (!arg1) {
50754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50755     return 0;
50756   }
50757   {
50758     try {
50759       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50760     } catch (std::out_of_range& e) {
50761       {
50762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50763       };
50764     } catch (std::exception& e) {
50765       {
50766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50767       };
50768     } catch (Dali::DaliException e) {
50769       {
50770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50771       };
50772     } catch (...) {
50773       {
50774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50775       };
50776     }
50777   }
50778
50779   jresult = (void *)result;
50780   return jresult;
50781 }
50782
50783
50784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50785   void * jresult ;
50786   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50787   Dali::Rect< float > *arg2 = 0 ;
50788   Dali::Rect< float > *result = 0 ;
50789
50790   arg1 = (Dali::Rect< float > *)jarg1;
50791   arg2 = (Dali::Rect< float > *)jarg2;
50792   if (!arg2) {
50793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50794     return 0;
50795   }
50796   {
50797     try {
50798       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50799     } catch (std::out_of_range& e) {
50800       {
50801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50802       };
50803     } catch (std::exception& e) {
50804       {
50805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50806       };
50807     } catch (Dali::DaliException e) {
50808       {
50809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50810       };
50811     } catch (...) {
50812       {
50813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50814       };
50815     }
50816   }
50817
50818   jresult = (void *)result;
50819   return jresult;
50820 }
50821
50822
50823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50824   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50825   float arg2 ;
50826   float arg3 ;
50827   float arg4 ;
50828   float arg5 ;
50829
50830   arg1 = (Dali::Rect< float > *)jarg1;
50831   arg2 = (float)jarg2;
50832   arg3 = (float)jarg3;
50833   arg4 = (float)jarg5;
50834   arg5 = (float)jarg4;
50835   {
50836     try {
50837       (arg1)->Set(arg2,arg3,arg4,arg5);
50838     } catch (std::out_of_range& e) {
50839       {
50840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50841       };
50842     } catch (std::exception& e) {
50843       {
50844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50845       };
50846     } catch (Dali::DaliException e) {
50847       {
50848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50849       };
50850     } catch (...) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50853       };
50854     }
50855   }
50856
50857 }
50858
50859
50860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50861   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50862   float arg2 ;
50863
50864   arg1 = (Dali::Rect< float > *)jarg1;
50865   arg2 = (float)jarg2;
50866   if (arg1) (arg1)->left = arg2;
50867 }
50868
50869
50870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50871   float jresult ;
50872   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50873   float result;
50874
50875   arg1 = (Dali::Rect< float > *)jarg1;
50876   result = (float) ((arg1)->left);
50877   jresult = result;
50878   return jresult;
50879 }
50880
50881
50882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50883   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50884   float arg2 ;
50885
50886   arg1 = (Dali::Rect< float > *)jarg1;
50887   arg2 = (float)jarg2;
50888   if (arg1) (arg1)->left = arg2;
50889 }
50890
50891
50892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50893   float jresult ;
50894   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50895   float result;
50896
50897   arg1 = (Dali::Rect< float > *)jarg1;
50898   result = (float) ((arg1)->left);
50899   jresult = result;
50900   return jresult;
50901 }
50902
50903
50904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50905   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50906   float arg2 ;
50907
50908   arg1 = (Dali::Rect< float > *)jarg1;
50909   arg2 = (float)jarg2;
50910   if (arg1) (arg1)->right = arg2;
50911 }
50912
50913
50914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50915   float jresult ;
50916   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50917   float result;
50918
50919   arg1 = (Dali::Rect< float > *)jarg1;
50920   result = (float) ((arg1)->right);
50921   jresult = result;
50922   return jresult;
50923 }
50924
50925
50926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50927   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50928   float arg2 ;
50929
50930   arg1 = (Dali::Rect< float > *)jarg1;
50931   arg2 = (float)jarg2;
50932   if (arg1) (arg1)->right = arg2;
50933 }
50934
50935
50936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50937   float jresult ;
50938   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50939   float result;
50940
50941   arg1 = (Dali::Rect< float > *)jarg1;
50942   result = (float) ((arg1)->right);
50943   jresult = result;
50944   return jresult;
50945 }
50946
50947
50948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50949   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50950   float arg2 ;
50951
50952   arg1 = (Dali::Rect< float > *)jarg1;
50953   arg2 = (float)jarg2;
50954   if (arg1) (arg1)->bottom = arg2;
50955 }
50956
50957
50958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50959   float jresult ;
50960   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50961   float result;
50962
50963   arg1 = (Dali::Rect< float > *)jarg1;
50964   result = (float) ((arg1)->bottom);
50965   jresult = result;
50966   return jresult;
50967 }
50968
50969
50970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50971   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50972   float arg2 ;
50973
50974   arg1 = (Dali::Rect< float > *)jarg1;
50975   arg2 = (float)jarg2;
50976   if (arg1) (arg1)->top = arg2;
50977 }
50978
50979
50980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50981   float jresult ;
50982   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50983   float result;
50984
50985   arg1 = (Dali::Rect< float > *)jarg1;
50986   result = (float) ((arg1)->top);
50987   jresult = result;
50988   return jresult;
50989 }
50990
50991
50992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50993   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50994
50995   arg1 = (Dali::Rect< float > *)jarg1;
50996   {
50997     try {
50998       delete arg1;
50999     } catch (std::out_of_range& e) {
51000       {
51001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51002       };
51003     } catch (std::exception& e) {
51004       {
51005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51006       };
51007     } catch (Dali::DaliException e) {
51008       {
51009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51010       };
51011     } catch (...) {
51012       {
51013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51014       };
51015     }
51016   }
51017
51018 }
51019
51020
51021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51022   int jresult ;
51023   int result;
51024
51025   result = (int)Dali::Vector< int >::BaseType;
51026   jresult = (int)result;
51027   return jresult;
51028 }
51029
51030
51031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51032   void * jresult ;
51033   Dali::Vector< int > *result = 0 ;
51034
51035   {
51036     try {
51037       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51038     } catch (std::out_of_range& e) {
51039       {
51040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51041       };
51042     } catch (std::exception& e) {
51043       {
51044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51045       };
51046     } catch (Dali::DaliException e) {
51047       {
51048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51049       };
51050     } catch (...) {
51051       {
51052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51053       };
51054     }
51055   }
51056
51057   jresult = (void *)result;
51058   return jresult;
51059 }
51060
51061
51062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51063   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51064
51065   arg1 = (Dali::Vector< int > *)jarg1;
51066   {
51067     try {
51068       delete arg1;
51069     } catch (std::out_of_range& e) {
51070       {
51071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51072       };
51073     } catch (std::exception& e) {
51074       {
51075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51076       };
51077     } catch (Dali::DaliException e) {
51078       {
51079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51080       };
51081     } catch (...) {
51082       {
51083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51084       };
51085     }
51086   }
51087
51088 }
51089
51090
51091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51092   void * jresult ;
51093   Dali::Vector< int > *arg1 = 0 ;
51094   Dali::Vector< int > *result = 0 ;
51095
51096   arg1 = (Dali::Vector< int > *)jarg1;
51097   if (!arg1) {
51098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51099     return 0;
51100   }
51101   {
51102     try {
51103       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51104     } catch (std::out_of_range& e) {
51105       {
51106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51107       };
51108     } catch (std::exception& e) {
51109       {
51110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51111       };
51112     } catch (Dali::DaliException e) {
51113       {
51114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51115       };
51116     } catch (...) {
51117       {
51118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51119       };
51120     }
51121   }
51122
51123   jresult = (void *)result;
51124   return jresult;
51125 }
51126
51127
51128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51129   void * jresult ;
51130   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51131   Dali::Vector< int > *arg2 = 0 ;
51132   Dali::Vector< int > *result = 0 ;
51133
51134   arg1 = (Dali::Vector< int > *)jarg1;
51135   arg2 = (Dali::Vector< int > *)jarg2;
51136   if (!arg2) {
51137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51138     return 0;
51139   }
51140   {
51141     try {
51142       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51143     } catch (std::out_of_range& e) {
51144       {
51145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51146       };
51147     } catch (std::exception& e) {
51148       {
51149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51150       };
51151     } catch (Dali::DaliException e) {
51152       {
51153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51154       };
51155     } catch (...) {
51156       {
51157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51158       };
51159     }
51160   }
51161
51162   jresult = (void *)result;
51163   return jresult;
51164 }
51165
51166
51167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51168   void * jresult ;
51169   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51170   Dali::Vector< int >::Iterator result;
51171
51172   arg1 = (Dali::Vector< int > *)jarg1;
51173   {
51174     try {
51175       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51176     } catch (std::out_of_range& e) {
51177       {
51178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51179       };
51180     } catch (std::exception& e) {
51181       {
51182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51183       };
51184     } catch (Dali::DaliException e) {
51185       {
51186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51187       };
51188     } catch (...) {
51189       {
51190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51191       };
51192     }
51193   }
51194
51195   jresult = (void *)result;
51196   return jresult;
51197 }
51198
51199
51200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51201   void * jresult ;
51202   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51203   Dali::Vector< int >::Iterator result;
51204
51205   arg1 = (Dali::Vector< int > *)jarg1;
51206   {
51207     try {
51208       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51209     } catch (std::out_of_range& e) {
51210       {
51211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51212       };
51213     } catch (std::exception& e) {
51214       {
51215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51216       };
51217     } catch (Dali::DaliException e) {
51218       {
51219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51220       };
51221     } catch (...) {
51222       {
51223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51224       };
51225     }
51226   }
51227
51228   jresult = (void *)result;
51229   return jresult;
51230 }
51231
51232
51233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51234   void * jresult ;
51235   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51236   Dali::Vector< int >::SizeType arg2 ;
51237   Dali::Vector< int >::ItemType *result = 0 ;
51238
51239   arg1 = (Dali::Vector< int > *)jarg1;
51240   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51241   {
51242     try {
51243       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51244     } catch (std::out_of_range& e) {
51245       {
51246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51247       };
51248     } catch (std::exception& e) {
51249       {
51250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51251       };
51252     } catch (Dali::DaliException e) {
51253       {
51254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51255       };
51256     } catch (...) {
51257       {
51258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51259       };
51260     }
51261   }
51262
51263   jresult = (void *)result;
51264   return jresult;
51265 }
51266
51267
51268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51269   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51270   Dali::Vector< int >::ItemType *arg2 = 0 ;
51271   Dali::Vector< int >::ItemType temp2 ;
51272
51273   arg1 = (Dali::Vector< int > *)jarg1;
51274   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51275   arg2 = &temp2;
51276   {
51277     try {
51278       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51279     } catch (std::out_of_range& e) {
51280       {
51281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (std::exception& e) {
51284       {
51285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51286       };
51287     } catch (Dali::DaliException e) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51290       };
51291     } catch (...) {
51292       {
51293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51294       };
51295     }
51296   }
51297
51298 }
51299
51300
51301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51302   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51303   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51304   Dali::Vector< int >::ItemType *arg3 = 0 ;
51305   Dali::Vector< int >::ItemType temp3 ;
51306
51307   arg1 = (Dali::Vector< int > *)jarg1;
51308   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51309   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51310   arg3 = &temp3;
51311   {
51312     try {
51313       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51314     } catch (std::out_of_range& e) {
51315       {
51316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51317       };
51318     } catch (std::exception& e) {
51319       {
51320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51321       };
51322     } catch (Dali::DaliException e) {
51323       {
51324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51325       };
51326     } catch (...) {
51327       {
51328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51329       };
51330     }
51331   }
51332
51333 }
51334
51335
51336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51337   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51338   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51339   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51340   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51341
51342   arg1 = (Dali::Vector< int > *)jarg1;
51343   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51344   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51345   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51346   {
51347     try {
51348       (arg1)->Insert(arg2,arg3,arg4);
51349     } catch (std::out_of_range& e) {
51350       {
51351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51352       };
51353     } catch (std::exception& e) {
51354       {
51355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51356       };
51357     } catch (Dali::DaliException e) {
51358       {
51359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51360       };
51361     } catch (...) {
51362       {
51363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51364       };
51365     }
51366   }
51367
51368 }
51369
51370
51371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51372   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51373   Dali::Vector< int >::SizeType arg2 ;
51374
51375   arg1 = (Dali::Vector< int > *)jarg1;
51376   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51377   {
51378     try {
51379       (arg1)->Reserve(arg2);
51380     } catch (std::out_of_range& e) {
51381       {
51382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51383       };
51384     } catch (std::exception& e) {
51385       {
51386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51387       };
51388     } catch (Dali::DaliException e) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51391       };
51392     } catch (...) {
51393       {
51394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51395       };
51396     }
51397   }
51398
51399 }
51400
51401
51402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51403   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51404   Dali::Vector< int >::SizeType arg2 ;
51405
51406   arg1 = (Dali::Vector< int > *)jarg1;
51407   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51408   {
51409     try {
51410       (arg1)->Resize(arg2);
51411     } catch (std::out_of_range& e) {
51412       {
51413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51414       };
51415     } catch (std::exception& e) {
51416       {
51417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51418       };
51419     } catch (Dali::DaliException e) {
51420       {
51421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51422       };
51423     } catch (...) {
51424       {
51425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51426       };
51427     }
51428   }
51429
51430 }
51431
51432
51433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51434   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51435   Dali::Vector< int >::SizeType arg2 ;
51436   Dali::Vector< int >::ItemType *arg3 = 0 ;
51437   Dali::Vector< int >::ItemType temp3 ;
51438
51439   arg1 = (Dali::Vector< int > *)jarg1;
51440   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51441   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51442   arg3 = &temp3;
51443   {
51444     try {
51445       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51446     } catch (std::out_of_range& e) {
51447       {
51448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51449       };
51450     } catch (std::exception& e) {
51451       {
51452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51453       };
51454     } catch (Dali::DaliException e) {
51455       {
51456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51457       };
51458     } catch (...) {
51459       {
51460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51461       };
51462     }
51463   }
51464
51465 }
51466
51467
51468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51469   void * jresult ;
51470   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51471   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51472   Dali::Vector< int >::Iterator result;
51473
51474   arg1 = (Dali::Vector< int > *)jarg1;
51475   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51476   {
51477     try {
51478       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51479     } catch (std::out_of_range& e) {
51480       {
51481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51482       };
51483     } catch (std::exception& e) {
51484       {
51485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51486       };
51487     } catch (Dali::DaliException e) {
51488       {
51489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51490       };
51491     } catch (...) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51494       };
51495     }
51496   }
51497
51498   jresult = (void *)result;
51499   return jresult;
51500 }
51501
51502
51503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51504   void * jresult ;
51505   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51506   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51507   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51508   Dali::Vector< int >::Iterator result;
51509
51510   arg1 = (Dali::Vector< int > *)jarg1;
51511   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51512   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51513   {
51514     try {
51515       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51516     } catch (std::out_of_range& e) {
51517       {
51518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51519       };
51520     } catch (std::exception& e) {
51521       {
51522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51523       };
51524     } catch (Dali::DaliException e) {
51525       {
51526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51527       };
51528     } catch (...) {
51529       {
51530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51531       };
51532     }
51533   }
51534
51535   jresult = (void *)result;
51536   return jresult;
51537 }
51538
51539
51540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51541   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51542   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51543
51544   arg1 = (Dali::Vector< int > *)jarg1;
51545   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51546   {
51547     try {
51548       (arg1)->Remove(arg2);
51549     } catch (std::out_of_range& e) {
51550       {
51551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51552       };
51553     } catch (std::exception& e) {
51554       {
51555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51556       };
51557     } catch (Dali::DaliException e) {
51558       {
51559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51560       };
51561     } catch (...) {
51562       {
51563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51564       };
51565     }
51566   }
51567
51568 }
51569
51570
51571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51572   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51573   Dali::Vector< int > *arg2 = 0 ;
51574
51575   arg1 = (Dali::Vector< int > *)jarg1;
51576   arg2 = (Dali::Vector< int > *)jarg2;
51577   if (!arg2) {
51578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51579     return ;
51580   }
51581   {
51582     try {
51583       (arg1)->Swap(*arg2);
51584     } catch (std::out_of_range& e) {
51585       {
51586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51587       };
51588     } catch (std::exception& e) {
51589       {
51590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51591       };
51592     } catch (Dali::DaliException e) {
51593       {
51594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51595       };
51596     } catch (...) {
51597       {
51598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51599       };
51600     }
51601   }
51602
51603 }
51604
51605
51606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51607   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51608
51609   arg1 = (Dali::Vector< int > *)jarg1;
51610   {
51611     try {
51612       (arg1)->Clear();
51613     } catch (std::out_of_range& e) {
51614       {
51615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51616       };
51617     } catch (std::exception& e) {
51618       {
51619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51620       };
51621     } catch (Dali::DaliException e) {
51622       {
51623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51624       };
51625     } catch (...) {
51626       {
51627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51628       };
51629     }
51630   }
51631
51632 }
51633
51634
51635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51636   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51637
51638   arg1 = (Dali::Vector< int > *)jarg1;
51639   {
51640     try {
51641       (arg1)->Release();
51642     } catch (std::out_of_range& e) {
51643       {
51644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51645       };
51646     } catch (std::exception& e) {
51647       {
51648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51649       };
51650     } catch (Dali::DaliException e) {
51651       {
51652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51653       };
51654     } catch (...) {
51655       {
51656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51657       };
51658     }
51659   }
51660
51661 }
51662
51663
51664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51665   int jresult ;
51666   int result;
51667
51668   result = (int)Dali::Vector< float >::BaseType;
51669   jresult = (int)result;
51670   return jresult;
51671 }
51672
51673
51674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51675   void * jresult ;
51676   Dali::Vector< float > *result = 0 ;
51677
51678   {
51679     try {
51680       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51681     } catch (std::out_of_range& e) {
51682       {
51683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51684       };
51685     } catch (std::exception& e) {
51686       {
51687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51688       };
51689     } catch (Dali::DaliException e) {
51690       {
51691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51692       };
51693     } catch (...) {
51694       {
51695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51696       };
51697     }
51698   }
51699
51700   jresult = (void *)result;
51701   return jresult;
51702 }
51703
51704
51705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51706   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51707
51708   arg1 = (Dali::Vector< float > *)jarg1;
51709   {
51710     try {
51711       delete arg1;
51712     } catch (std::out_of_range& e) {
51713       {
51714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51715       };
51716     } catch (std::exception& e) {
51717       {
51718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51719       };
51720     } catch (Dali::DaliException e) {
51721       {
51722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51723       };
51724     } catch (...) {
51725       {
51726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51727       };
51728     }
51729   }
51730
51731 }
51732
51733
51734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51735   void * jresult ;
51736   Dali::Vector< float > *arg1 = 0 ;
51737   Dali::Vector< float > *result = 0 ;
51738
51739   arg1 = (Dali::Vector< float > *)jarg1;
51740   if (!arg1) {
51741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51742     return 0;
51743   }
51744   {
51745     try {
51746       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51747     } catch (std::out_of_range& e) {
51748       {
51749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51750       };
51751     } catch (std::exception& e) {
51752       {
51753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51754       };
51755     } catch (Dali::DaliException e) {
51756       {
51757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51758       };
51759     } catch (...) {
51760       {
51761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51762       };
51763     }
51764   }
51765
51766   jresult = (void *)result;
51767   return jresult;
51768 }
51769
51770
51771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51772   void * jresult ;
51773   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51774   Dali::Vector< float > *arg2 = 0 ;
51775   Dali::Vector< float > *result = 0 ;
51776
51777   arg1 = (Dali::Vector< float > *)jarg1;
51778   arg2 = (Dali::Vector< float > *)jarg2;
51779   if (!arg2) {
51780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51781     return 0;
51782   }
51783   {
51784     try {
51785       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51786     } catch (std::out_of_range& e) {
51787       {
51788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51789       };
51790     } catch (std::exception& e) {
51791       {
51792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51793       };
51794     } catch (Dali::DaliException e) {
51795       {
51796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51797       };
51798     } catch (...) {
51799       {
51800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51801       };
51802     }
51803   }
51804
51805   jresult = (void *)result;
51806   return jresult;
51807 }
51808
51809
51810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51811   void * jresult ;
51812   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51813   Dali::Vector< float >::Iterator result;
51814
51815   arg1 = (Dali::Vector< float > *)jarg1;
51816   {
51817     try {
51818       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51819     } catch (std::out_of_range& e) {
51820       {
51821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51822       };
51823     } catch (std::exception& e) {
51824       {
51825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51826       };
51827     } catch (Dali::DaliException e) {
51828       {
51829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51830       };
51831     } catch (...) {
51832       {
51833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51834       };
51835     }
51836   }
51837
51838   jresult = (void *)result;
51839   return jresult;
51840 }
51841
51842
51843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51844   void * jresult ;
51845   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51846   Dali::Vector< float >::Iterator result;
51847
51848   arg1 = (Dali::Vector< float > *)jarg1;
51849   {
51850     try {
51851       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51852     } catch (std::out_of_range& e) {
51853       {
51854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51855       };
51856     } catch (std::exception& e) {
51857       {
51858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51859       };
51860     } catch (Dali::DaliException e) {
51861       {
51862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51863       };
51864     } catch (...) {
51865       {
51866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51867       };
51868     }
51869   }
51870
51871   jresult = (void *)result;
51872   return jresult;
51873 }
51874
51875
51876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51877   void * jresult ;
51878   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51879   Dali::Vector< float >::SizeType arg2 ;
51880   Dali::Vector< float >::ItemType *result = 0 ;
51881
51882   arg1 = (Dali::Vector< float > *)jarg1;
51883   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51884   {
51885     try {
51886       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51887     } catch (std::out_of_range& e) {
51888       {
51889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51890       };
51891     } catch (std::exception& e) {
51892       {
51893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51894       };
51895     } catch (Dali::DaliException e) {
51896       {
51897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51898       };
51899     } catch (...) {
51900       {
51901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51902       };
51903     }
51904   }
51905
51906   jresult = (void *)result;
51907   return jresult;
51908 }
51909
51910
51911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51912   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51913   Dali::Vector< float >::ItemType *arg2 = 0 ;
51914   Dali::Vector< float >::ItemType temp2 ;
51915
51916   arg1 = (Dali::Vector< float > *)jarg1;
51917   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51918   arg2 = &temp2;
51919   {
51920     try {
51921       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51922     } catch (std::out_of_range& e) {
51923       {
51924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51925       };
51926     } catch (std::exception& e) {
51927       {
51928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51929       };
51930     } catch (Dali::DaliException e) {
51931       {
51932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51933       };
51934     } catch (...) {
51935       {
51936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51937       };
51938     }
51939   }
51940
51941 }
51942
51943
51944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51945   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51946   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51947   Dali::Vector< float >::ItemType *arg3 = 0 ;
51948   Dali::Vector< float >::ItemType temp3 ;
51949
51950   arg1 = (Dali::Vector< float > *)jarg1;
51951   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51952   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51953   arg3 = &temp3;
51954   {
51955     try {
51956       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51957     } catch (std::out_of_range& e) {
51958       {
51959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51960       };
51961     } catch (std::exception& e) {
51962       {
51963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51964       };
51965     } catch (Dali::DaliException e) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51968       };
51969     } catch (...) {
51970       {
51971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51972       };
51973     }
51974   }
51975
51976 }
51977
51978
51979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51980   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51981   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51982   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51983   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51984
51985   arg1 = (Dali::Vector< float > *)jarg1;
51986   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51987   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51988   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51989   {
51990     try {
51991       (arg1)->Insert(arg2,arg3,arg4);
51992     } catch (std::out_of_range& e) {
51993       {
51994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51995       };
51996     } catch (std::exception& e) {
51997       {
51998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51999       };
52000     } catch (Dali::DaliException e) {
52001       {
52002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52003       };
52004     } catch (...) {
52005       {
52006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52007       };
52008     }
52009   }
52010
52011 }
52012
52013
52014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52015   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52016   Dali::Vector< float >::SizeType arg2 ;
52017
52018   arg1 = (Dali::Vector< float > *)jarg1;
52019   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52020   {
52021     try {
52022       (arg1)->Reserve(arg2);
52023     } catch (std::out_of_range& e) {
52024       {
52025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52026       };
52027     } catch (std::exception& e) {
52028       {
52029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52030       };
52031     } catch (Dali::DaliException e) {
52032       {
52033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52034       };
52035     } catch (...) {
52036       {
52037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52038       };
52039     }
52040   }
52041
52042 }
52043
52044 //// ========================= end of part 2 =============================
52045
52046 //// ========================== start part 3 ===============================
52047
52048
52049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52050   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52051   Dali::Vector< float >::SizeType arg2 ;
52052
52053   arg1 = (Dali::Vector< float > *)jarg1;
52054   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52055   {
52056     try {
52057       (arg1)->Resize(arg2);
52058     } catch (std::out_of_range& e) {
52059       {
52060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52061       };
52062     } catch (std::exception& e) {
52063       {
52064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52065       };
52066     } catch (Dali::DaliException e) {
52067       {
52068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52069       };
52070     } catch (...) {
52071       {
52072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52073       };
52074     }
52075   }
52076
52077 }
52078
52079
52080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52081   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52082   Dali::Vector< float >::SizeType arg2 ;
52083   Dali::Vector< float >::ItemType *arg3 = 0 ;
52084   Dali::Vector< float >::ItemType temp3 ;
52085
52086   arg1 = (Dali::Vector< float > *)jarg1;
52087   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52088   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52089   arg3 = &temp3;
52090   {
52091     try {
52092       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52093     } catch (std::out_of_range& e) {
52094       {
52095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52096       };
52097     } catch (std::exception& e) {
52098       {
52099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52100       };
52101     } catch (Dali::DaliException e) {
52102       {
52103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52104       };
52105     } catch (...) {
52106       {
52107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52108       };
52109     }
52110   }
52111
52112 }
52113
52114
52115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52116   void * jresult ;
52117   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52118   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52119   Dali::Vector< float >::Iterator result;
52120
52121   arg1 = (Dali::Vector< float > *)jarg1;
52122   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52123   {
52124     try {
52125       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52126     } catch (std::out_of_range& e) {
52127       {
52128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52129       };
52130     } catch (std::exception& e) {
52131       {
52132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52133       };
52134     } catch (Dali::DaliException e) {
52135       {
52136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52137       };
52138     } catch (...) {
52139       {
52140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52141       };
52142     }
52143   }
52144
52145   jresult = (void *)result;
52146   return jresult;
52147 }
52148
52149
52150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52151   void * jresult ;
52152   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52153   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52154   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52155   Dali::Vector< float >::Iterator result;
52156
52157   arg1 = (Dali::Vector< float > *)jarg1;
52158   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52159   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52160   {
52161     try {
52162       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52163     } catch (std::out_of_range& e) {
52164       {
52165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52166       };
52167     } catch (std::exception& e) {
52168       {
52169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52170       };
52171     } catch (Dali::DaliException e) {
52172       {
52173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52174       };
52175     } catch (...) {
52176       {
52177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52178       };
52179     }
52180   }
52181
52182   jresult = (void *)result;
52183   return jresult;
52184 }
52185
52186
52187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52188   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52189   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52190
52191   arg1 = (Dali::Vector< float > *)jarg1;
52192   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52193   {
52194     try {
52195       (arg1)->Remove(arg2);
52196     } catch (std::out_of_range& e) {
52197       {
52198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52199       };
52200     } catch (std::exception& e) {
52201       {
52202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52203       };
52204     } catch (Dali::DaliException e) {
52205       {
52206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52207       };
52208     } catch (...) {
52209       {
52210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52211       };
52212     }
52213   }
52214
52215 }
52216
52217
52218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52219   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52220   Dali::Vector< float > *arg2 = 0 ;
52221
52222   arg1 = (Dali::Vector< float > *)jarg1;
52223   arg2 = (Dali::Vector< float > *)jarg2;
52224   if (!arg2) {
52225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52226     return ;
52227   }
52228   {
52229     try {
52230       (arg1)->Swap(*arg2);
52231     } catch (std::out_of_range& e) {
52232       {
52233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52234       };
52235     } catch (std::exception& e) {
52236       {
52237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52238       };
52239     } catch (Dali::DaliException e) {
52240       {
52241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52242       };
52243     } catch (...) {
52244       {
52245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52246       };
52247     }
52248   }
52249
52250 }
52251
52252
52253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52254   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52255
52256   arg1 = (Dali::Vector< float > *)jarg1;
52257   {
52258     try {
52259       (arg1)->Clear();
52260     } catch (std::out_of_range& e) {
52261       {
52262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52263       };
52264     } catch (std::exception& e) {
52265       {
52266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52267       };
52268     } catch (Dali::DaliException e) {
52269       {
52270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52271       };
52272     } catch (...) {
52273       {
52274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52275       };
52276     }
52277   }
52278
52279 }
52280
52281
52282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52283   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52284
52285   arg1 = (Dali::Vector< float > *)jarg1;
52286   {
52287     try {
52288       (arg1)->Release();
52289     } catch (std::out_of_range& e) {
52290       {
52291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52292       };
52293     } catch (std::exception& e) {
52294       {
52295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52296       };
52297     } catch (Dali::DaliException e) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52300       };
52301     } catch (...) {
52302       {
52303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52304       };
52305     }
52306   }
52307
52308 }
52309
52310
52311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52312   int jresult ;
52313   int result;
52314
52315   result = (int)Dali::Vector< unsigned char >::BaseType;
52316   jresult = (int)result;
52317   return jresult;
52318 }
52319
52320
52321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52322   void * jresult ;
52323   Dali::Vector< unsigned char > *result = 0 ;
52324
52325   {
52326     try {
52327       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52328     } catch (std::out_of_range& e) {
52329       {
52330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52331       };
52332     } catch (std::exception& e) {
52333       {
52334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52335       };
52336     } catch (Dali::DaliException e) {
52337       {
52338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52339       };
52340     } catch (...) {
52341       {
52342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52343       };
52344     }
52345   }
52346
52347   jresult = (void *)result;
52348   return jresult;
52349 }
52350
52351
52352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52353   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52354
52355   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52356   {
52357     try {
52358       delete arg1;
52359     } catch (std::out_of_range& e) {
52360       {
52361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52362       };
52363     } catch (std::exception& e) {
52364       {
52365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52366       };
52367     } catch (Dali::DaliException e) {
52368       {
52369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52370       };
52371     } catch (...) {
52372       {
52373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52374       };
52375     }
52376   }
52377
52378 }
52379
52380
52381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52382   void * jresult ;
52383   Dali::Vector< unsigned char > *arg1 = 0 ;
52384   Dali::Vector< unsigned char > *result = 0 ;
52385
52386   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52387   if (!arg1) {
52388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52389     return 0;
52390   }
52391   {
52392     try {
52393       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52394     } catch (std::out_of_range& e) {
52395       {
52396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52397       };
52398     } catch (std::exception& e) {
52399       {
52400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52401       };
52402     } catch (Dali::DaliException e) {
52403       {
52404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52405       };
52406     } catch (...) {
52407       {
52408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52409       };
52410     }
52411   }
52412
52413   jresult = (void *)result;
52414   return jresult;
52415 }
52416
52417
52418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52419   void * jresult ;
52420   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52421   Dali::Vector< unsigned char > *arg2 = 0 ;
52422   Dali::Vector< unsigned char > *result = 0 ;
52423
52424   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52425   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52426   if (!arg2) {
52427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52428     return 0;
52429   }
52430   {
52431     try {
52432       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52433     } catch (std::out_of_range& e) {
52434       {
52435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52436       };
52437     } catch (std::exception& e) {
52438       {
52439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52440       };
52441     } catch (Dali::DaliException e) {
52442       {
52443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52444       };
52445     } catch (...) {
52446       {
52447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52448       };
52449     }
52450   }
52451
52452   jresult = (void *)result;
52453   return jresult;
52454 }
52455
52456
52457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52458   void * jresult ;
52459   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52460   Dali::Vector< unsigned char >::Iterator result;
52461
52462   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52463   {
52464     try {
52465       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52466     } catch (std::out_of_range& e) {
52467       {
52468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52469       };
52470     } catch (std::exception& e) {
52471       {
52472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52473       };
52474     } catch (Dali::DaliException e) {
52475       {
52476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52477       };
52478     } catch (...) {
52479       {
52480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52481       };
52482     }
52483   }
52484
52485   jresult = (void *)result;
52486   return jresult;
52487 }
52488
52489
52490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52491   void * jresult ;
52492   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52493   Dali::Vector< unsigned char >::Iterator result;
52494
52495   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52496   {
52497     try {
52498       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52499     } catch (std::out_of_range& e) {
52500       {
52501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52502       };
52503     } catch (std::exception& e) {
52504       {
52505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52506       };
52507     } catch (Dali::DaliException e) {
52508       {
52509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52510       };
52511     } catch (...) {
52512       {
52513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52514       };
52515     }
52516   }
52517
52518   jresult = (void *)result;
52519   return jresult;
52520 }
52521
52522
52523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52524   void * jresult ;
52525   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52526   Dali::Vector< unsigned char >::SizeType arg2 ;
52527   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52528
52529   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52530   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52531   {
52532     try {
52533       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52534     } catch (std::out_of_range& e) {
52535       {
52536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52537       };
52538     } catch (std::exception& e) {
52539       {
52540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52541       };
52542     } catch (Dali::DaliException e) {
52543       {
52544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52545       };
52546     } catch (...) {
52547       {
52548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52549       };
52550     }
52551   }
52552
52553   jresult = (void *)result;
52554   return jresult;
52555 }
52556
52557
52558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52559   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52560   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52561   Dali::Vector< unsigned char >::ItemType temp2 ;
52562
52563   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52564   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52565   arg2 = &temp2;
52566   {
52567     try {
52568       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52569     } catch (std::out_of_range& e) {
52570       {
52571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52572       };
52573     } catch (std::exception& e) {
52574       {
52575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52576       };
52577     } catch (Dali::DaliException e) {
52578       {
52579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52580       };
52581     } catch (...) {
52582       {
52583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52584       };
52585     }
52586   }
52587
52588 }
52589
52590
52591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52592   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52593   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52594   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52595   Dali::Vector< unsigned char >::ItemType temp3 ;
52596
52597   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52598   arg2 = jarg2;
52599   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52600   arg3 = &temp3;
52601   {
52602     try {
52603       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52604     } catch (std::out_of_range& e) {
52605       {
52606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52607       };
52608     } catch (std::exception& e) {
52609       {
52610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52611       };
52612     } catch (Dali::DaliException e) {
52613       {
52614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52615       };
52616     } catch (...) {
52617       {
52618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52619       };
52620     }
52621   }
52622
52623
52624
52625 }
52626
52627
52628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52629   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52630   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52631   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52632   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52633
52634   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52635   arg2 = jarg2;
52636   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52637   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52638   {
52639     try {
52640       (arg1)->Insert(arg2,arg3,arg4);
52641     } catch (std::out_of_range& e) {
52642       {
52643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52644       };
52645     } catch (std::exception& e) {
52646       {
52647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52648       };
52649     } catch (Dali::DaliException e) {
52650       {
52651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52652       };
52653     } catch (...) {
52654       {
52655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52656       };
52657     }
52658   }
52659
52660
52661
52662 }
52663
52664
52665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52666   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52667   Dali::Vector< unsigned char >::SizeType arg2 ;
52668
52669   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52670   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52671   {
52672     try {
52673       (arg1)->Reserve(arg2);
52674     } catch (std::out_of_range& e) {
52675       {
52676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52677       };
52678     } catch (std::exception& e) {
52679       {
52680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52681       };
52682     } catch (Dali::DaliException e) {
52683       {
52684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52685       };
52686     } catch (...) {
52687       {
52688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52689       };
52690     }
52691   }
52692
52693 }
52694
52695
52696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52697   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52698   Dali::Vector< unsigned char >::SizeType arg2 ;
52699
52700   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52701   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52702   {
52703     try {
52704       (arg1)->Resize(arg2);
52705     } catch (std::out_of_range& e) {
52706       {
52707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52708       };
52709     } catch (std::exception& e) {
52710       {
52711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52712       };
52713     } catch (Dali::DaliException e) {
52714       {
52715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52716       };
52717     } catch (...) {
52718       {
52719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52720       };
52721     }
52722   }
52723
52724 }
52725
52726
52727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52728   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52729   Dali::Vector< unsigned char >::SizeType arg2 ;
52730   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52731   Dali::Vector< unsigned char >::ItemType temp3 ;
52732
52733   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52734   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52735   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52736   arg3 = &temp3;
52737   {
52738     try {
52739       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52740     } catch (std::out_of_range& e) {
52741       {
52742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52743       };
52744     } catch (std::exception& e) {
52745       {
52746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52747       };
52748     } catch (Dali::DaliException e) {
52749       {
52750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52751       };
52752     } catch (...) {
52753       {
52754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52755       };
52756     }
52757   }
52758
52759 }
52760
52761
52762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52763   void * jresult ;
52764   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52765   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52766   Dali::Vector< unsigned char >::Iterator result;
52767
52768   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52769   arg2 = jarg2;
52770   {
52771     try {
52772       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52773     } catch (std::out_of_range& e) {
52774       {
52775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52776       };
52777     } catch (std::exception& e) {
52778       {
52779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52780       };
52781     } catch (Dali::DaliException e) {
52782       {
52783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52784       };
52785     } catch (...) {
52786       {
52787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52788       };
52789     }
52790   }
52791
52792   jresult = (void *)result;
52793
52794
52795   return jresult;
52796 }
52797
52798
52799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52800   void * jresult ;
52801   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52802   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52803   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52804   Dali::Vector< unsigned char >::Iterator result;
52805
52806   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52807   arg2 = jarg2;
52808   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52809   {
52810     try {
52811       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52812     } catch (std::out_of_range& e) {
52813       {
52814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52815       };
52816     } catch (std::exception& e) {
52817       {
52818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (Dali::DaliException e) {
52821       {
52822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52823       };
52824     } catch (...) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52827       };
52828     }
52829   }
52830
52831   jresult = (void *)result;
52832
52833
52834   return jresult;
52835 }
52836
52837
52838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52839   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52840   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52841
52842   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52843   arg2 = jarg2;
52844   {
52845     try {
52846       (arg1)->Remove(arg2);
52847     } catch (std::out_of_range& e) {
52848       {
52849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52850       };
52851     } catch (std::exception& e) {
52852       {
52853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52854       };
52855     } catch (Dali::DaliException e) {
52856       {
52857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52858       };
52859     } catch (...) {
52860       {
52861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52862       };
52863     }
52864   }
52865
52866
52867
52868 }
52869
52870
52871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52872   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52873   Dali::Vector< unsigned char > *arg2 = 0 ;
52874
52875   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52876   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52877   if (!arg2) {
52878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52879     return ;
52880   }
52881   {
52882     try {
52883       (arg1)->Swap(*arg2);
52884     } catch (std::out_of_range& e) {
52885       {
52886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52887       };
52888     } catch (std::exception& e) {
52889       {
52890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52891       };
52892     } catch (Dali::DaliException e) {
52893       {
52894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52895       };
52896     } catch (...) {
52897       {
52898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52899       };
52900     }
52901   }
52902
52903 }
52904
52905
52906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52907   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52908
52909   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52910   {
52911     try {
52912       (arg1)->Clear();
52913     } catch (std::out_of_range& e) {
52914       {
52915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52916       };
52917     } catch (std::exception& e) {
52918       {
52919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52920       };
52921     } catch (Dali::DaliException e) {
52922       {
52923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52924       };
52925     } catch (...) {
52926       {
52927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52928       };
52929     }
52930   }
52931
52932 }
52933
52934
52935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52936   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52937
52938   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52939   {
52940     try {
52941       (arg1)->Release();
52942     } catch (std::out_of_range& e) {
52943       {
52944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52945       };
52946     } catch (std::exception& e) {
52947       {
52948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52949       };
52950     } catch (Dali::DaliException e) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52953       };
52954     } catch (...) {
52955       {
52956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52957       };
52958     }
52959   }
52960
52961 }
52962
52963
52964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52965   int jresult ;
52966   int result;
52967
52968   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52969   jresult = (int)result;
52970   return jresult;
52971 }
52972
52973
52974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52975   void * jresult ;
52976   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52977
52978   {
52979     try {
52980       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52981     } catch (std::out_of_range& e) {
52982       {
52983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52984       };
52985     } catch (std::exception& e) {
52986       {
52987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52988       };
52989     } catch (Dali::DaliException e) {
52990       {
52991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52992       };
52993     } catch (...) {
52994       {
52995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52996       };
52997     }
52998   }
52999
53000   jresult = (void *)result;
53001   return jresult;
53002 }
53003
53004
53005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53006   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53007
53008   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53009   {
53010     try {
53011       delete arg1;
53012     } catch (std::out_of_range& e) {
53013       {
53014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53015       };
53016     } catch (std::exception& e) {
53017       {
53018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53019       };
53020     } catch (Dali::DaliException e) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53023       };
53024     } catch (...) {
53025       {
53026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53027       };
53028     }
53029   }
53030
53031 }
53032
53033
53034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53035   void * jresult ;
53036   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53037   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53038
53039   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53040   if (!arg1) {
53041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53042     return 0;
53043   }
53044   {
53045     try {
53046       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53047     } catch (std::out_of_range& e) {
53048       {
53049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53050       };
53051     } catch (std::exception& e) {
53052       {
53053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53054       };
53055     } catch (Dali::DaliException e) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53062       };
53063     }
53064   }
53065
53066   jresult = (void *)result;
53067   return jresult;
53068 }
53069
53070
53071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53072   void * jresult ;
53073   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53074   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53075   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53076
53077   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53078   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53079   if (!arg2) {
53080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53081     return 0;
53082   }
53083   {
53084     try {
53085       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53086     } catch (std::out_of_range& e) {
53087       {
53088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53089       };
53090     } catch (std::exception& e) {
53091       {
53092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53093       };
53094     } catch (Dali::DaliException e) {
53095       {
53096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53097       };
53098     } catch (...) {
53099       {
53100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53101       };
53102     }
53103   }
53104
53105   jresult = (void *)result;
53106   return jresult;
53107 }
53108
53109
53110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53111   void * jresult ;
53112   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53113   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53114
53115   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53116   {
53117     try {
53118       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53119     } catch (std::out_of_range& e) {
53120       {
53121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53122       };
53123     } catch (std::exception& e) {
53124       {
53125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53126       };
53127     } catch (Dali::DaliException e) {
53128       {
53129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53130       };
53131     } catch (...) {
53132       {
53133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53134       };
53135     }
53136   }
53137
53138   jresult = (void *)result;
53139   return jresult;
53140 }
53141
53142
53143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53144   void * jresult ;
53145   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53146   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53147
53148   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53149   {
53150     try {
53151       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53152     } catch (std::out_of_range& e) {
53153       {
53154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53155       };
53156     } catch (std::exception& e) {
53157       {
53158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53159       };
53160     } catch (Dali::DaliException e) {
53161       {
53162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53163       };
53164     } catch (...) {
53165       {
53166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53167       };
53168     }
53169   }
53170
53171   jresult = (void *)result;
53172   return jresult;
53173 }
53174
53175
53176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53177   void * jresult ;
53178   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53179   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53180   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53181
53182   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53183   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53184   {
53185     try {
53186       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53187     } catch (std::out_of_range& e) {
53188       {
53189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53190       };
53191     } catch (std::exception& e) {
53192       {
53193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53194       };
53195     } catch (Dali::DaliException e) {
53196       {
53197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53198       };
53199     } catch (...) {
53200       {
53201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53202       };
53203     }
53204   }
53205
53206   jresult = (void *)result;
53207   return jresult;
53208 }
53209
53210
53211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53212   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53213   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53214
53215   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53216   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53217   if (!arg2) {
53218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53219     return ;
53220   }
53221   {
53222     try {
53223       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53224     } catch (std::out_of_range& e) {
53225       {
53226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53227       };
53228     } catch (std::exception& e) {
53229       {
53230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53231       };
53232     } catch (Dali::DaliException e) {
53233       {
53234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53235       };
53236     } catch (...) {
53237       {
53238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53239       };
53240     }
53241   }
53242
53243 }
53244
53245
53246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53247   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53248   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53249   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53250
53251   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53252   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53253   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53254   if (!arg3) {
53255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53256     return ;
53257   }
53258   {
53259     try {
53260       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (Dali::DaliException e) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53272       };
53273     } catch (...) {
53274       {
53275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53276       };
53277     }
53278   }
53279
53280 }
53281
53282
53283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53284   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53285   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53286   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53287   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53288
53289   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53290   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53291   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53292   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53293   {
53294     try {
53295       (arg1)->Insert(arg2,arg3,arg4);
53296     } catch (std::out_of_range& e) {
53297       {
53298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53299       };
53300     } catch (std::exception& e) {
53301       {
53302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53303       };
53304     } catch (Dali::DaliException e) {
53305       {
53306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53307       };
53308     } catch (...) {
53309       {
53310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53311       };
53312     }
53313   }
53314
53315 }
53316
53317
53318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53319   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53320   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53321
53322   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53323   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53324   {
53325     try {
53326       (arg1)->Reserve(arg2);
53327     } catch (std::out_of_range& e) {
53328       {
53329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53330       };
53331     } catch (std::exception& e) {
53332       {
53333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53334       };
53335     } catch (Dali::DaliException e) {
53336       {
53337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53338       };
53339     } catch (...) {
53340       {
53341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53342       };
53343     }
53344   }
53345
53346 }
53347
53348
53349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53350   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53351   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53352
53353   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53354   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53355   {
53356     try {
53357       (arg1)->Resize(arg2);
53358     } catch (std::out_of_range& e) {
53359       {
53360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53361       };
53362     } catch (std::exception& e) {
53363       {
53364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53365       };
53366     } catch (Dali::DaliException e) {
53367       {
53368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53369       };
53370     } catch (...) {
53371       {
53372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53373       };
53374     }
53375   }
53376
53377 }
53378
53379
53380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53381   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53382   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53383   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53384
53385   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53386   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53387   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53388   if (!arg3) {
53389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53390     return ;
53391   }
53392   {
53393     try {
53394       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53395     } catch (std::out_of_range& e) {
53396       {
53397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53398       };
53399     } catch (std::exception& e) {
53400       {
53401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53402       };
53403     } catch (Dali::DaliException e) {
53404       {
53405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53406       };
53407     } catch (...) {
53408       {
53409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53410       };
53411     }
53412   }
53413
53414 }
53415
53416
53417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53418   void * jresult ;
53419   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53420   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53421   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53422
53423   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53424   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53425   {
53426     try {
53427       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53428     } catch (std::out_of_range& e) {
53429       {
53430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53431       };
53432     } catch (std::exception& e) {
53433       {
53434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53435       };
53436     } catch (Dali::DaliException e) {
53437       {
53438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53439       };
53440     } catch (...) {
53441       {
53442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53443       };
53444     }
53445   }
53446
53447   jresult = (void *)result;
53448   return jresult;
53449 }
53450
53451
53452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53453   void * jresult ;
53454   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53455   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53456   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53457   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53458
53459   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53460   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53461   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53462   {
53463     try {
53464       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53465     } catch (std::out_of_range& e) {
53466       {
53467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53468       };
53469     } catch (std::exception& e) {
53470       {
53471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53472       };
53473     } catch (Dali::DaliException e) {
53474       {
53475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53476       };
53477     } catch (...) {
53478       {
53479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53480       };
53481     }
53482   }
53483
53484   jresult = (void *)result;
53485   return jresult;
53486 }
53487
53488
53489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53490   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53491   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53492
53493   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53494   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53495   {
53496     try {
53497       (arg1)->Remove(arg2);
53498     } catch (std::out_of_range& e) {
53499       {
53500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53501       };
53502     } catch (std::exception& e) {
53503       {
53504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53505       };
53506     } catch (Dali::DaliException e) {
53507       {
53508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53509       };
53510     } catch (...) {
53511       {
53512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53513       };
53514     }
53515   }
53516
53517 }
53518
53519
53520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53521   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53522   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53523
53524   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53525   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53526   if (!arg2) {
53527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53528     return ;
53529   }
53530   {
53531     try {
53532       (arg1)->Swap(*arg2);
53533     } catch (std::out_of_range& e) {
53534       {
53535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53536       };
53537     } catch (std::exception& e) {
53538       {
53539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53540       };
53541     } catch (Dali::DaliException e) {
53542       {
53543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53544       };
53545     } catch (...) {
53546       {
53547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53548       };
53549     }
53550   }
53551
53552 }
53553
53554
53555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53556   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53557
53558   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53559   {
53560     try {
53561       (arg1)->Clear();
53562     } catch (std::out_of_range& e) {
53563       {
53564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53565       };
53566     } catch (std::exception& e) {
53567       {
53568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53569       };
53570     } catch (Dali::DaliException e) {
53571       {
53572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53573       };
53574     } catch (...) {
53575       {
53576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53577       };
53578     }
53579   }
53580
53581 }
53582
53583
53584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53585   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53586
53587   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53588   {
53589     try {
53590       (arg1)->Release();
53591     } catch (std::out_of_range& e) {
53592       {
53593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53594       };
53595     } catch (std::exception& e) {
53596       {
53597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53598       };
53599     } catch (Dali::DaliException e) {
53600       {
53601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53602       };
53603     } catch (...) {
53604       {
53605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53606       };
53607     }
53608   }
53609
53610 }
53611
53612
53613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53614   void * jresult ;
53615   Dali::Signal< void () > *result = 0 ;
53616
53617   {
53618     try {
53619       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53620     } catch (std::out_of_range& e) {
53621       {
53622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53623       };
53624     } catch (std::exception& e) {
53625       {
53626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53627       };
53628     } catch (Dali::DaliException e) {
53629       {
53630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53631       };
53632     } catch (...) {
53633       {
53634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53635       };
53636     }
53637   }
53638
53639   jresult = (void *)result;
53640   return jresult;
53641 }
53642
53643
53644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53645   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53646
53647   arg1 = (Dali::Signal< void () > *)jarg1;
53648   {
53649     try {
53650       delete arg1;
53651     } catch (std::out_of_range& e) {
53652       {
53653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53654       };
53655     } catch (std::exception& e) {
53656       {
53657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53658       };
53659     } catch (Dali::DaliException e) {
53660       {
53661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53662       };
53663     } catch (...) {
53664       {
53665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53666       };
53667     }
53668   }
53669
53670 }
53671
53672
53673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53674   unsigned int jresult ;
53675   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53676   bool result;
53677
53678   arg1 = (Dali::Signal< void () > *)jarg1;
53679   {
53680     try {
53681       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53682     } catch (std::out_of_range& e) {
53683       {
53684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53685       };
53686     } catch (std::exception& e) {
53687       {
53688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53689       };
53690     } catch (Dali::DaliException e) {
53691       {
53692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53693       };
53694     } catch (...) {
53695       {
53696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53697       };
53698     }
53699   }
53700
53701   jresult = result;
53702   return jresult;
53703 }
53704
53705
53706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53707   unsigned long jresult ;
53708   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53709   std::size_t result;
53710
53711   arg1 = (Dali::Signal< void () > *)jarg1;
53712   {
53713     try {
53714       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53715     } catch (std::out_of_range& e) {
53716       {
53717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53718       };
53719     } catch (std::exception& e) {
53720       {
53721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53722       };
53723     } catch (Dali::DaliException e) {
53724       {
53725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53726       };
53727     } catch (...) {
53728       {
53729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53730       };
53731     }
53732   }
53733
53734   jresult = (unsigned long)result;
53735   return jresult;
53736 }
53737
53738
53739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53740   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53741   void (*arg2)() = (void (*)()) 0 ;
53742
53743   arg1 = (Dali::Signal< void () > *)jarg1;
53744   arg2 = (void (*)())jarg2;
53745   {
53746     try {
53747       (arg1)->Connect(arg2);
53748     } catch (std::out_of_range& e) {
53749       {
53750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53751       };
53752     } catch (std::exception& e) {
53753       {
53754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53755       };
53756     } catch (Dali::DaliException e) {
53757       {
53758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53759       };
53760     } catch (...) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53763       };
53764     }
53765   }
53766
53767 }
53768
53769
53770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53771   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53772   void (*arg2)() = (void (*)()) 0 ;
53773
53774   arg1 = (Dali::Signal< void () > *)jarg1;
53775   arg2 = (void (*)())jarg2;
53776   {
53777     try {
53778       (arg1)->Disconnect(arg2);
53779     } catch (std::out_of_range& e) {
53780       {
53781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53782       };
53783     } catch (std::exception& e) {
53784       {
53785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53786       };
53787     } catch (Dali::DaliException e) {
53788       {
53789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53790       };
53791     } catch (...) {
53792       {
53793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53794       };
53795     }
53796   }
53797
53798 }
53799
53800
53801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53802   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53803   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53804   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53805
53806   arg1 = (Dali::Signal< void () > *)jarg1;
53807   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53808   arg3 = (Dali::FunctorDelegate *)jarg3;
53809   {
53810     try {
53811       (arg1)->Connect(arg2,arg3);
53812     } catch (std::out_of_range& e) {
53813       {
53814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53815       };
53816     } catch (std::exception& e) {
53817       {
53818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53819       };
53820     } catch (Dali::DaliException e) {
53821       {
53822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53823       };
53824     } catch (...) {
53825       {
53826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53827       };
53828     }
53829   }
53830
53831 }
53832
53833
53834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53835   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53836
53837   arg1 = (Dali::Signal< void () > *)jarg1;
53838   {
53839     try {
53840       (arg1)->Emit();
53841     } catch (std::out_of_range& e) {
53842       {
53843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53844       };
53845     } catch (std::exception& e) {
53846       {
53847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53848       };
53849     } catch (Dali::DaliException e) {
53850       {
53851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53852       };
53853     } catch (...) {
53854       {
53855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53856       };
53857     }
53858   }
53859
53860 }
53861
53862
53863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53864   unsigned int jresult ;
53865   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53866   bool result;
53867
53868   arg1 = (Dali::Signal< void (float) > *)jarg1;
53869   {
53870     try {
53871       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53872     } catch (std::out_of_range& e) {
53873       {
53874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53875       };
53876     } catch (std::exception& e) {
53877       {
53878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53879       };
53880     } catch (Dali::DaliException e) {
53881       {
53882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53883       };
53884     } catch (...) {
53885       {
53886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53887       };
53888     }
53889   }
53890
53891   jresult = result;
53892   return jresult;
53893 }
53894
53895
53896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53897   unsigned long jresult ;
53898   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53899   std::size_t result;
53900
53901   arg1 = (Dali::Signal< void (float) > *)jarg1;
53902   {
53903     try {
53904       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53905     } catch (std::out_of_range& e) {
53906       {
53907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53908       };
53909     } catch (std::exception& e) {
53910       {
53911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53912       };
53913     } catch (Dali::DaliException e) {
53914       {
53915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53916       };
53917     } catch (...) {
53918       {
53919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53920       };
53921     }
53922   }
53923
53924   jresult = (unsigned long)result;
53925   return jresult;
53926 }
53927
53928
53929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53930   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53931   void (*arg2)(float) = (void (*)(float)) 0 ;
53932
53933   arg1 = (Dali::Signal< void (float) > *)jarg1;
53934   arg2 = (void (*)(float))jarg2;
53935   {
53936     try {
53937       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53938     } catch (std::out_of_range& e) {
53939       {
53940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53941       };
53942     } catch (std::exception& e) {
53943       {
53944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53945       };
53946     } catch (Dali::DaliException e) {
53947       {
53948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53949       };
53950     } catch (...) {
53951       {
53952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53953       };
53954     }
53955   }
53956
53957 }
53958
53959
53960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53961   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53962   void (*arg2)(float) = (void (*)(float)) 0 ;
53963
53964   arg1 = (Dali::Signal< void (float) > *)jarg1;
53965   arg2 = (void (*)(float))jarg2;
53966   {
53967     try {
53968       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53969     } catch (std::out_of_range& e) {
53970       {
53971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53972       };
53973     } catch (std::exception& e) {
53974       {
53975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53976       };
53977     } catch (Dali::DaliException e) {
53978       {
53979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53980       };
53981     } catch (...) {
53982       {
53983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53984       };
53985     }
53986   }
53987
53988 }
53989
53990
53991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53992   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53993   float arg2 ;
53994
53995   arg1 = (Dali::Signal< void (float) > *)jarg1;
53996   arg2 = (float)jarg2;
53997   {
53998     try {
53999       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54000     } catch (std::out_of_range& e) {
54001       {
54002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54003       };
54004     } catch (std::exception& e) {
54005       {
54006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54007       };
54008     } catch (Dali::DaliException e) {
54009       {
54010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54011       };
54012     } catch (...) {
54013       {
54014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54015       };
54016     }
54017   }
54018
54019 }
54020
54021
54022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54023   void * jresult ;
54024   Dali::Signal< void (float) > *result = 0 ;
54025
54026   {
54027     try {
54028       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54029     } catch (std::out_of_range& e) {
54030       {
54031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54032       };
54033     } catch (std::exception& e) {
54034       {
54035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54036       };
54037     } catch (Dali::DaliException e) {
54038       {
54039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54040       };
54041     } catch (...) {
54042       {
54043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54044       };
54045     }
54046   }
54047
54048   jresult = (void *)result;
54049   return jresult;
54050 }
54051
54052
54053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54054   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54055
54056   arg1 = (Dali::Signal< void (float) > *)jarg1;
54057   {
54058     try {
54059       delete arg1;
54060     } catch (std::out_of_range& e) {
54061       {
54062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54063       };
54064     } catch (std::exception& e) {
54065       {
54066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54067       };
54068     } catch (Dali::DaliException e) {
54069       {
54070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54071       };
54072     } catch (...) {
54073       {
54074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54075       };
54076     }
54077   }
54078
54079 }
54080
54081
54082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54083   unsigned int jresult ;
54084   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54085   bool result;
54086
54087   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54088   {
54089     try {
54090       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54091     } catch (std::out_of_range& e) {
54092       {
54093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54094       };
54095     } catch (std::exception& e) {
54096       {
54097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54098       };
54099     } catch (Dali::DaliException e) {
54100       {
54101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54102       };
54103     } catch (...) {
54104       {
54105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54106       };
54107     }
54108   }
54109
54110   jresult = result;
54111   return jresult;
54112 }
54113
54114
54115 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54116   unsigned long jresult ;
54117   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54118   std::size_t result;
54119
54120   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54121   {
54122     try {
54123       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54124     } catch (std::out_of_range& e) {
54125       {
54126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54127       };
54128     } catch (std::exception& e) {
54129       {
54130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54131       };
54132     } catch (Dali::DaliException e) {
54133       {
54134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54135       };
54136     } catch (...) {
54137       {
54138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54139       };
54140     }
54141   }
54142
54143   jresult = (unsigned long)result;
54144   return jresult;
54145 }
54146
54147
54148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54149   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54150   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54151
54152   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54153   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54154   {
54155     try {
54156       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54157     } catch (std::out_of_range& e) {
54158       {
54159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54160       };
54161     } catch (std::exception& e) {
54162       {
54163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54164       };
54165     } catch (Dali::DaliException e) {
54166       {
54167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54168       };
54169     } catch (...) {
54170       {
54171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54172       };
54173     }
54174   }
54175
54176 }
54177
54178
54179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54180   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54181   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54182
54183   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54184   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54185   {
54186     try {
54187       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54188     } catch (std::out_of_range& e) {
54189       {
54190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54191       };
54192     } catch (std::exception& e) {
54193       {
54194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54195       };
54196     } catch (Dali::DaliException e) {
54197       {
54198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54199       };
54200     } catch (...) {
54201       {
54202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54203       };
54204     }
54205   }
54206
54207 }
54208
54209
54210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54211   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54212   Dali::BaseHandle arg2 ;
54213   Dali::BaseHandle *argp2 ;
54214
54215   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54216   argp2 = (Dali::BaseHandle *)jarg2;
54217   if (!argp2) {
54218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54219     return ;
54220   }
54221   arg2 = *argp2;
54222   {
54223     try {
54224       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54225     } catch (std::out_of_range& e) {
54226       {
54227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54228       };
54229     } catch (std::exception& e) {
54230       {
54231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54232       };
54233     } catch (Dali::DaliException e) {
54234       {
54235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54236       };
54237     } catch (...) {
54238       {
54239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54240       };
54241     }
54242   }
54243
54244 }
54245
54246
54247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54248   void * jresult ;
54249   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54250
54251   {
54252     try {
54253       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54254     } catch (std::out_of_range& e) {
54255       {
54256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54257       };
54258     } catch (std::exception& e) {
54259       {
54260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54261       };
54262     } catch (Dali::DaliException e) {
54263       {
54264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54265       };
54266     } catch (...) {
54267       {
54268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54269       };
54270     }
54271   }
54272
54273   jresult = (void *)result;
54274   return jresult;
54275 }
54276
54277
54278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54279   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54280
54281   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54282   {
54283     try {
54284       delete arg1;
54285     } catch (std::out_of_range& e) {
54286       {
54287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54288       };
54289     } catch (std::exception& e) {
54290       {
54291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54292       };
54293     } catch (Dali::DaliException e) {
54294       {
54295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54296       };
54297     } catch (...) {
54298       {
54299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54300       };
54301     }
54302   }
54303
54304 }
54305
54306
54307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54308   unsigned int jresult ;
54309   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54310   bool result;
54311
54312   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54313   {
54314     try {
54315       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54316     } catch (std::out_of_range& e) {
54317       {
54318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54319       };
54320     } catch (std::exception& e) {
54321       {
54322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54323       };
54324     } catch (Dali::DaliException e) {
54325       {
54326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54327       };
54328     } catch (...) {
54329       {
54330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54331       };
54332     }
54333   }
54334
54335   jresult = result;
54336   return jresult;
54337 }
54338
54339
54340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54341   unsigned long jresult ;
54342   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54343   std::size_t result;
54344
54345   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54346   {
54347     try {
54348       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54349     } catch (std::out_of_range& e) {
54350       {
54351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54352       };
54353     } catch (std::exception& e) {
54354       {
54355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54356       };
54357     } catch (Dali::DaliException e) {
54358       {
54359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54360       };
54361     } catch (...) {
54362       {
54363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54364       };
54365     }
54366   }
54367
54368   jresult = (unsigned long)result;
54369   return jresult;
54370 }
54371
54372
54373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54374   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54375   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54376
54377   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54378   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54379   {
54380     try {
54381       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54382     } catch (std::out_of_range& e) {
54383       {
54384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54385       };
54386     } catch (std::exception& e) {
54387       {
54388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54389       };
54390     } catch (Dali::DaliException e) {
54391       {
54392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54393       };
54394     } catch (...) {
54395       {
54396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54397       };
54398     }
54399   }
54400
54401 }
54402
54403
54404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54405   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54406   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54407
54408   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54409   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54410   {
54411     try {
54412       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54413     } catch (std::out_of_range& e) {
54414       {
54415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54416       };
54417     } catch (std::exception& e) {
54418       {
54419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54420       };
54421     } catch (Dali::DaliException e) {
54422       {
54423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54424       };
54425     } catch (...) {
54426       {
54427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54428       };
54429     }
54430   }
54431
54432 }
54433
54434
54435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54436   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54437   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54438
54439   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54440   arg2 = (Dali::RefObject *)jarg2;
54441   {
54442     try {
54443       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54444     } catch (std::out_of_range& e) {
54445       {
54446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54447       };
54448     } catch (std::exception& e) {
54449       {
54450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54451       };
54452     } catch (Dali::DaliException e) {
54453       {
54454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54455       };
54456     } catch (...) {
54457       {
54458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54459       };
54460     }
54461   }
54462
54463 }
54464
54465
54466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54467   void * jresult ;
54468   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54469
54470   {
54471     try {
54472       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54480       };
54481     } catch (Dali::DaliException e) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54484       };
54485     } catch (...) {
54486       {
54487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54488       };
54489     }
54490   }
54491
54492   jresult = (void *)result;
54493   return jresult;
54494 }
54495
54496
54497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54498   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54499
54500   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54501   {
54502     try {
54503       delete arg1;
54504     } catch (std::out_of_range& e) {
54505       {
54506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54507       };
54508     } catch (std::exception& e) {
54509       {
54510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54511       };
54512     } catch (Dali::DaliException e) {
54513       {
54514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54515       };
54516     } catch (...) {
54517       {
54518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54519       };
54520     }
54521   }
54522
54523 }
54524
54525
54526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54527   unsigned int jresult ;
54528   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54529   bool result;
54530
54531   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54532   {
54533     try {
54534       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54535     } catch (std::out_of_range& e) {
54536       {
54537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54538       };
54539     } catch (std::exception& e) {
54540       {
54541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54542       };
54543     } catch (Dali::DaliException e) {
54544       {
54545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54546       };
54547     } catch (...) {
54548       {
54549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54550       };
54551     }
54552   }
54553
54554   jresult = result;
54555   return jresult;
54556 }
54557
54558
54559 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54560   unsigned long jresult ;
54561   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54562   std::size_t result;
54563
54564   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54565   {
54566     try {
54567       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54568     } catch (std::out_of_range& e) {
54569       {
54570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54571       };
54572     } catch (std::exception& e) {
54573       {
54574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54575       };
54576     } catch (Dali::DaliException e) {
54577       {
54578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54579       };
54580     } catch (...) {
54581       {
54582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54583       };
54584     }
54585   }
54586
54587   jresult = (unsigned long)result;
54588   return jresult;
54589 }
54590
54591
54592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54593   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54594   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54595
54596   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54597   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54598   {
54599     try {
54600       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54601     } catch (std::out_of_range& e) {
54602       {
54603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54604       };
54605     } catch (std::exception& e) {
54606       {
54607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54608       };
54609     } catch (Dali::DaliException e) {
54610       {
54611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54612       };
54613     } catch (...) {
54614       {
54615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54616       };
54617     }
54618   }
54619
54620 }
54621
54622
54623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54624   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54625   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54626
54627   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54628   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54629   {
54630     try {
54631       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54632     } catch (std::out_of_range& e) {
54633       {
54634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54635       };
54636     } catch (std::exception& e) {
54637       {
54638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54639       };
54640     } catch (Dali::DaliException e) {
54641       {
54642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54643       };
54644     } catch (...) {
54645       {
54646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54647       };
54648     }
54649   }
54650
54651 }
54652
54653
54654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54655   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54656   Dali::PropertyNotification *arg2 = 0 ;
54657
54658   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54659   arg2 = (Dali::PropertyNotification *)jarg2;
54660   if (!arg2) {
54661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54662     return ;
54663   }
54664   {
54665     try {
54666       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54667     } catch (std::out_of_range& e) {
54668       {
54669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54670       };
54671     } catch (std::exception& e) {
54672       {
54673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54674       };
54675     } catch (Dali::DaliException e) {
54676       {
54677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54678       };
54679     } catch (...) {
54680       {
54681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54682       };
54683     }
54684   }
54685
54686 }
54687
54688
54689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54690   void * jresult ;
54691   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54692
54693   {
54694     try {
54695       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54696     } catch (std::out_of_range& e) {
54697       {
54698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54699       };
54700     } catch (std::exception& e) {
54701       {
54702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54703       };
54704     } catch (Dali::DaliException e) {
54705       {
54706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54707       };
54708     } catch (...) {
54709       {
54710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54711       };
54712     }
54713   }
54714
54715   jresult = (void *)result;
54716   return jresult;
54717 }
54718
54719
54720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54721   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54722
54723   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54724   {
54725     try {
54726       delete arg1;
54727     } catch (std::out_of_range& e) {
54728       {
54729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54730       };
54731     } catch (std::exception& e) {
54732       {
54733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54734       };
54735     } catch (Dali::DaliException e) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54738       };
54739     } catch (...) {
54740       {
54741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54742       };
54743     }
54744   }
54745
54746 }
54747
54748
54749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54750   unsigned int jresult ;
54751   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54752   bool result;
54753
54754   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54755   {
54756     try {
54757       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54758     } catch (std::out_of_range& e) {
54759       {
54760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54761       };
54762     } catch (std::exception& e) {
54763       {
54764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54765       };
54766     } catch (Dali::DaliException e) {
54767       {
54768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54769       };
54770     } catch (...) {
54771       {
54772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54773       };
54774     }
54775   }
54776
54777   jresult = result;
54778   return jresult;
54779 }
54780
54781
54782 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54783   unsigned long jresult ;
54784   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54785   std::size_t result;
54786
54787   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54788   {
54789     try {
54790       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54791     } catch (std::out_of_range& e) {
54792       {
54793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54794       };
54795     } catch (std::exception& e) {
54796       {
54797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54798       };
54799     } catch (Dali::DaliException e) {
54800       {
54801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54802       };
54803     } catch (...) {
54804       {
54805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54806       };
54807     }
54808   }
54809
54810   jresult = (unsigned long)result;
54811   return jresult;
54812 }
54813
54814
54815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54816   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54817   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54818
54819   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54820   arg2 = (void (*)(Dali::Image))jarg2;
54821   {
54822     try {
54823       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54824     } catch (std::out_of_range& e) {
54825       {
54826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54827       };
54828     } catch (std::exception& e) {
54829       {
54830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54831       };
54832     } catch (Dali::DaliException e) {
54833       {
54834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54835       };
54836     } catch (...) {
54837       {
54838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54839       };
54840     }
54841   }
54842
54843 }
54844
54845
54846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54847   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54848   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54849
54850   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54851   arg2 = (void (*)(Dali::Image))jarg2;
54852   {
54853     try {
54854       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54855     } catch (std::out_of_range& e) {
54856       {
54857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54858       };
54859     } catch (std::exception& e) {
54860       {
54861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54862       };
54863     } catch (Dali::DaliException e) {
54864       {
54865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54866       };
54867     } catch (...) {
54868       {
54869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54870       };
54871     }
54872   }
54873
54874 }
54875
54876
54877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54878   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54879   Dali::Image arg2 ;
54880   Dali::Image *argp2 ;
54881
54882   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54883   argp2 = (Dali::Image *)jarg2;
54884   if (!argp2) {
54885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54886     return ;
54887   }
54888   arg2 = *argp2;
54889   {
54890     try {
54891       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54892     } catch (std::out_of_range& e) {
54893       {
54894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54895       };
54896     } catch (std::exception& e) {
54897       {
54898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54899       };
54900     } catch (Dali::DaliException e) {
54901       {
54902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54903       };
54904     } catch (...) {
54905       {
54906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54907       };
54908     }
54909   }
54910
54911 }
54912
54913
54914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54915   void * jresult ;
54916   Dali::Signal< void (Dali::Image) > *result = 0 ;
54917
54918   {
54919     try {
54920       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54921     } catch (std::out_of_range& e) {
54922       {
54923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54924       };
54925     } catch (std::exception& e) {
54926       {
54927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54928       };
54929     } catch (Dali::DaliException e) {
54930       {
54931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54932       };
54933     } catch (...) {
54934       {
54935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54936       };
54937     }
54938   }
54939
54940   jresult = (void *)result;
54941   return jresult;
54942 }
54943
54944
54945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54946   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54947
54948   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54949   {
54950     try {
54951       delete arg1;
54952     } catch (std::out_of_range& e) {
54953       {
54954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54955       };
54956     } catch (std::exception& e) {
54957       {
54958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54959       };
54960     } catch (Dali::DaliException e) {
54961       {
54962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54963       };
54964     } catch (...) {
54965       {
54966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54967       };
54968     }
54969   }
54970
54971 }
54972
54973
54974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54975   void * jresult ;
54976   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54977
54978   {
54979     try {
54980       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54981     } catch (std::out_of_range& e) {
54982       {
54983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54984       };
54985     } catch (std::exception& e) {
54986       {
54987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54988       };
54989     } catch (Dali::DaliException e) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54992       };
54993     } catch (...) {
54994       {
54995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54996       };
54997     }
54998   }
54999
55000   jresult = (void *)result;
55001   return jresult;
55002 }
55003
55004
55005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55006   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55007
55008   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55009   {
55010     try {
55011       delete arg1;
55012     } catch (std::out_of_range& e) {
55013       {
55014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55015       };
55016     } catch (std::exception& e) {
55017       {
55018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55019       };
55020     } catch (Dali::DaliException e) {
55021       {
55022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55023       };
55024     } catch (...) {
55025       {
55026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55027       };
55028     }
55029   }
55030
55031 }
55032
55033
55034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55035   unsigned int jresult ;
55036   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55037   bool result;
55038
55039   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55040   {
55041     try {
55042       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);
55043     } catch (std::out_of_range& e) {
55044       {
55045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55046       };
55047     } catch (std::exception& e) {
55048       {
55049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55050       };
55051     } catch (Dali::DaliException e) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55054       };
55055     } catch (...) {
55056       {
55057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55058       };
55059     }
55060   }
55061
55062   jresult = result;
55063   return jresult;
55064 }
55065
55066
55067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55068   unsigned long jresult ;
55069   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55070   std::size_t result;
55071
55072   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55073   {
55074     try {
55075       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);
55076     } catch (std::out_of_range& e) {
55077       {
55078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55079       };
55080     } catch (std::exception& e) {
55081       {
55082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55083       };
55084     } catch (Dali::DaliException e) {
55085       {
55086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55087       };
55088     } catch (...) {
55089       {
55090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55091       };
55092     }
55093   }
55094
55095   jresult = (unsigned long)result;
55096   return jresult;
55097 }
55098
55099
55100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55101   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55102   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55103
55104   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55105   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55106   {
55107     try {
55108       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55109     } catch (std::out_of_range& e) {
55110       {
55111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55112       };
55113     } catch (std::exception& e) {
55114       {
55115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55116       };
55117     } catch (Dali::DaliException e) {
55118       {
55119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55120       };
55121     } catch (...) {
55122       {
55123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55124       };
55125     }
55126   }
55127
55128 }
55129
55130
55131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55132   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55133   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55134
55135   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55136   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55137   {
55138     try {
55139       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55140     } catch (std::out_of_range& e) {
55141       {
55142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55143       };
55144     } catch (std::exception& e) {
55145       {
55146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55147       };
55148     } catch (Dali::DaliException e) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55151       };
55152     } catch (...) {
55153       {
55154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55155       };
55156     }
55157   }
55158
55159 }
55160
55161
55162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55163   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55164   Dali::Actor arg2 ;
55165   Dali::LongPressGesture *arg3 = 0 ;
55166   Dali::Actor *argp2 ;
55167
55168   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55169   argp2 = (Dali::Actor *)jarg2;
55170   if (!argp2) {
55171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55172     return ;
55173   }
55174   arg2 = *argp2;
55175   arg3 = (Dali::LongPressGesture *)jarg3;
55176   if (!arg3) {
55177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55178     return ;
55179   }
55180   {
55181     try {
55182       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55183     } catch (std::out_of_range& e) {
55184       {
55185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55186       };
55187     } catch (std::exception& e) {
55188       {
55189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55190       };
55191     } catch (Dali::DaliException e) {
55192       {
55193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55194       };
55195     } catch (...) {
55196       {
55197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55198       };
55199     }
55200   }
55201
55202 }
55203
55204
55205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55206   void * jresult ;
55207   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55208
55209   {
55210     try {
55211       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55212     } catch (std::out_of_range& e) {
55213       {
55214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55215       };
55216     } catch (std::exception& e) {
55217       {
55218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55219       };
55220     } catch (Dali::DaliException e) {
55221       {
55222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55223       };
55224     } catch (...) {
55225       {
55226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55227       };
55228     }
55229   }
55230
55231   jresult = (void *)result;
55232   return jresult;
55233 }
55234
55235
55236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55237   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55238
55239   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55240   {
55241     try {
55242       delete arg1;
55243     } catch (std::out_of_range& e) {
55244       {
55245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55246       };
55247     } catch (std::exception& e) {
55248       {
55249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55250       };
55251     } catch (Dali::DaliException e) {
55252       {
55253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55254       };
55255     } catch (...) {
55256       {
55257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55258       };
55259     }
55260   }
55261
55262 }
55263
55264
55265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55266   unsigned int jresult ;
55267   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55268   bool result;
55269
55270   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55271   {
55272     try {
55273       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);
55274     } catch (std::out_of_range& e) {
55275       {
55276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55277       };
55278     } catch (std::exception& e) {
55279       {
55280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55281       };
55282     } catch (Dali::DaliException e) {
55283       {
55284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55285       };
55286     } catch (...) {
55287       {
55288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55289       };
55290     }
55291   }
55292
55293   jresult = result;
55294   return jresult;
55295 }
55296
55297
55298 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55299   unsigned long jresult ;
55300   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55301   std::size_t result;
55302
55303   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55304   {
55305     try {
55306       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);
55307     } catch (std::out_of_range& e) {
55308       {
55309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55310       };
55311     } catch (std::exception& e) {
55312       {
55313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55314       };
55315     } catch (Dali::DaliException e) {
55316       {
55317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55318       };
55319     } catch (...) {
55320       {
55321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55322       };
55323     }
55324   }
55325
55326   jresult = (unsigned long)result;
55327   return jresult;
55328 }
55329
55330
55331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55332   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55333   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55334
55335   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55336   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55337   {
55338     try {
55339       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55340     } catch (std::out_of_range& e) {
55341       {
55342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55343       };
55344     } catch (std::exception& e) {
55345       {
55346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55347       };
55348     } catch (Dali::DaliException e) {
55349       {
55350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55351       };
55352     } catch (...) {
55353       {
55354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55355       };
55356     }
55357   }
55358
55359 }
55360
55361
55362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55363   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55364   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55365
55366   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55367   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55368   {
55369     try {
55370       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55371     } catch (std::out_of_range& e) {
55372       {
55373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55374       };
55375     } catch (std::exception& e) {
55376       {
55377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55378       };
55379     } catch (Dali::DaliException e) {
55380       {
55381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55382       };
55383     } catch (...) {
55384       {
55385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55386       };
55387     }
55388   }
55389
55390 }
55391
55392
55393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55394   unsigned int jresult ;
55395   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55396   Dali::Actor arg2 ;
55397   Dali::TouchData *arg3 = 0 ;
55398   Dali::Actor *argp2 ;
55399   bool result;
55400
55401   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55402   argp2 = (Dali::Actor *)jarg2;
55403   if (!argp2) {
55404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55405     return 0;
55406   }
55407   arg2 = *argp2;
55408   arg3 = (Dali::TouchData *)jarg3;
55409   if (!arg3) {
55410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55411     return 0;
55412   }
55413   {
55414     try {
55415       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55416     } catch (std::out_of_range& e) {
55417       {
55418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55419       };
55420     } catch (std::exception& e) {
55421       {
55422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55423       };
55424     } catch (Dali::DaliException e) {
55425       {
55426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55427       };
55428     } catch (...) {
55429       {
55430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55431       };
55432     }
55433   }
55434
55435   jresult = result;
55436   return jresult;
55437 }
55438
55439
55440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55441   void * jresult ;
55442   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55443
55444   {
55445     try {
55446       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55447     } catch (std::out_of_range& e) {
55448       {
55449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55450       };
55451     } catch (std::exception& e) {
55452       {
55453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55454       };
55455     } catch (Dali::DaliException e) {
55456       {
55457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55458       };
55459     } catch (...) {
55460       {
55461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55462       };
55463     }
55464   }
55465
55466   jresult = (void *)result;
55467   return jresult;
55468 }
55469
55470
55471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55472   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55473
55474   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55475   {
55476     try {
55477       delete arg1;
55478     } catch (std::out_of_range& e) {
55479       {
55480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55481       };
55482     } catch (std::exception& e) {
55483       {
55484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55485       };
55486     } catch (Dali::DaliException e) {
55487       {
55488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55489       };
55490     } catch (...) {
55491       {
55492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55493       };
55494     }
55495   }
55496
55497 }
55498
55499
55500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55501   unsigned int jresult ;
55502   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55503   bool result;
55504
55505   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55506   {
55507     try {
55508       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);
55509     } catch (std::out_of_range& e) {
55510       {
55511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55512       };
55513     } catch (std::exception& e) {
55514       {
55515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55516       };
55517     } catch (Dali::DaliException e) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55520       };
55521     } catch (...) {
55522       {
55523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55524       };
55525     }
55526   }
55527
55528   jresult = result;
55529   return jresult;
55530 }
55531
55532
55533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55534   unsigned long jresult ;
55535   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55536   std::size_t result;
55537
55538   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55539   {
55540     try {
55541       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);
55542     } catch (std::out_of_range& e) {
55543       {
55544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55545       };
55546     } catch (std::exception& e) {
55547       {
55548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55549       };
55550     } catch (Dali::DaliException e) {
55551       {
55552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55553       };
55554     } catch (...) {
55555       {
55556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55557       };
55558     }
55559   }
55560
55561   jresult = (unsigned long)result;
55562   return jresult;
55563 }
55564
55565
55566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55567   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55568   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55569
55570   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55571   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55572   {
55573     try {
55574       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55575     } catch (std::out_of_range& e) {
55576       {
55577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55578       };
55579     } catch (std::exception& e) {
55580       {
55581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55582       };
55583     } catch (Dali::DaliException e) {
55584       {
55585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55586       };
55587     } catch (...) {
55588       {
55589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55590       };
55591     }
55592   }
55593
55594 }
55595
55596
55597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55598   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55599   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55600
55601   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55602   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55603   {
55604     try {
55605       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55606     } catch (std::out_of_range& e) {
55607       {
55608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55609       };
55610     } catch (std::exception& e) {
55611       {
55612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55613       };
55614     } catch (Dali::DaliException e) {
55615       {
55616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55617       };
55618     } catch (...) {
55619       {
55620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55621       };
55622     }
55623   }
55624
55625 }
55626
55627
55628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55629   unsigned int jresult ;
55630   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55631   Dali::Actor arg2 ;
55632   Dali::HoverEvent *arg3 = 0 ;
55633   Dali::Actor *argp2 ;
55634   bool result;
55635
55636   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55637   argp2 = (Dali::Actor *)jarg2;
55638   if (!argp2) {
55639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55640     return 0;
55641   }
55642   arg2 = *argp2;
55643   arg3 = (Dali::HoverEvent *)jarg3;
55644   if (!arg3) {
55645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55646     return 0;
55647   }
55648   {
55649     try {
55650       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55651     } catch (std::out_of_range& e) {
55652       {
55653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55654       };
55655     } catch (std::exception& e) {
55656       {
55657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55658       };
55659     } catch (Dali::DaliException e) {
55660       {
55661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55662       };
55663     } catch (...) {
55664       {
55665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55666       };
55667     }
55668   }
55669
55670   jresult = result;
55671   return jresult;
55672 }
55673
55674
55675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55676   void * jresult ;
55677   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55678
55679   {
55680     try {
55681       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55682     } catch (std::out_of_range& e) {
55683       {
55684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55685       };
55686     } catch (std::exception& e) {
55687       {
55688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55689       };
55690     } catch (Dali::DaliException e) {
55691       {
55692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55693       };
55694     } catch (...) {
55695       {
55696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55697       };
55698     }
55699   }
55700
55701   jresult = (void *)result;
55702   return jresult;
55703 }
55704
55705
55706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55707   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55708
55709   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55710   {
55711     try {
55712       delete arg1;
55713     } catch (std::out_of_range& e) {
55714       {
55715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55716       };
55717     } catch (std::exception& e) {
55718       {
55719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55720       };
55721     } catch (Dali::DaliException e) {
55722       {
55723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55724       };
55725     } catch (...) {
55726       {
55727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55728       };
55729     }
55730   }
55731
55732 }
55733
55734
55735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55736   unsigned int jresult ;
55737   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55738   bool result;
55739
55740   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55741   {
55742     try {
55743       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);
55744     } catch (std::out_of_range& e) {
55745       {
55746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (std::exception& e) {
55749       {
55750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55751       };
55752     } catch (Dali::DaliException e) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55755       };
55756     } catch (...) {
55757       {
55758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55759       };
55760     }
55761   }
55762
55763   jresult = result;
55764   return jresult;
55765 }
55766
55767
55768 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55769   unsigned long jresult ;
55770   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55771   std::size_t result;
55772
55773   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55774   {
55775     try {
55776       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);
55777     } catch (std::out_of_range& e) {
55778       {
55779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55780       };
55781     } catch (std::exception& e) {
55782       {
55783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55784       };
55785     } catch (Dali::DaliException e) {
55786       {
55787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55788       };
55789     } catch (...) {
55790       {
55791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55792       };
55793     }
55794   }
55795
55796   jresult = (unsigned long)result;
55797   return jresult;
55798 }
55799
55800
55801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55802   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55803   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55804
55805   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55806   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55807   {
55808     try {
55809       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55810     } catch (std::out_of_range& e) {
55811       {
55812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55813       };
55814     } catch (std::exception& e) {
55815       {
55816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55817       };
55818     } catch (Dali::DaliException e) {
55819       {
55820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55821       };
55822     } catch (...) {
55823       {
55824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55825       };
55826     }
55827   }
55828
55829 }
55830
55831
55832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55833   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55834   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55835
55836   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55837   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55838   {
55839     try {
55840       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55841     } catch (std::out_of_range& e) {
55842       {
55843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55844       };
55845     } catch (std::exception& e) {
55846       {
55847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55848       };
55849     } catch (Dali::DaliException e) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55852       };
55853     } catch (...) {
55854       {
55855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55856       };
55857     }
55858   }
55859
55860 }
55861
55862
55863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55864   unsigned int jresult ;
55865   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55866   Dali::Actor arg2 ;
55867   Dali::WheelEvent *arg3 = 0 ;
55868   Dali::Actor *argp2 ;
55869   bool result;
55870
55871   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55872   argp2 = (Dali::Actor *)jarg2;
55873   if (!argp2) {
55874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55875     return 0;
55876   }
55877   arg2 = *argp2;
55878   arg3 = (Dali::WheelEvent *)jarg3;
55879   if (!arg3) {
55880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55881     return 0;
55882   }
55883   {
55884     try {
55885       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55886     } catch (std::out_of_range& e) {
55887       {
55888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55889       };
55890     } catch (std::exception& e) {
55891       {
55892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55893       };
55894     } catch (Dali::DaliException e) {
55895       {
55896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55897       };
55898     } catch (...) {
55899       {
55900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55901       };
55902     }
55903   }
55904
55905   jresult = result;
55906   return jresult;
55907 }
55908
55909
55910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55911   void * jresult ;
55912   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55913
55914   {
55915     try {
55916       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55917     } catch (std::out_of_range& e) {
55918       {
55919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55920       };
55921     } catch (std::exception& e) {
55922       {
55923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55924       };
55925     } catch (Dali::DaliException e) {
55926       {
55927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55928       };
55929     } catch (...) {
55930       {
55931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55932       };
55933     }
55934   }
55935
55936   jresult = (void *)result;
55937   return jresult;
55938 }
55939
55940
55941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55942   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55943
55944   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55945   {
55946     try {
55947       delete arg1;
55948     } catch (std::out_of_range& e) {
55949       {
55950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55951       };
55952     } catch (std::exception& e) {
55953       {
55954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55955       };
55956     } catch (Dali::DaliException e) {
55957       {
55958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55959       };
55960     } catch (...) {
55961       {
55962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55963       };
55964     }
55965   }
55966
55967 }
55968
55969
55970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55971   unsigned int jresult ;
55972   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55973   bool result;
55974
55975   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55976   {
55977     try {
55978       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55979     } catch (std::out_of_range& e) {
55980       {
55981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55982       };
55983     } catch (std::exception& e) {
55984       {
55985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55986       };
55987     } catch (Dali::DaliException e) {
55988       {
55989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55990       };
55991     } catch (...) {
55992       {
55993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55994       };
55995     }
55996   }
55997
55998   jresult = result;
55999   return jresult;
56000 }
56001
56002
56003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56004   unsigned long jresult ;
56005   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56006   std::size_t result;
56007
56008   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56009   {
56010     try {
56011       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56012     } catch (std::out_of_range& e) {
56013       {
56014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56015       };
56016     } catch (std::exception& e) {
56017       {
56018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56019       };
56020     } catch (Dali::DaliException e) {
56021       {
56022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56023       };
56024     } catch (...) {
56025       {
56026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56027       };
56028     }
56029   }
56030
56031   jresult = (unsigned long)result;
56032   return jresult;
56033 }
56034
56035
56036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56037   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56038   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56039
56040   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56041   arg2 = (void (*)(Dali::Actor))jarg2;
56042   {
56043     try {
56044       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56045     } catch (std::out_of_range& e) {
56046       {
56047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56048       };
56049     } catch (std::exception& e) {
56050       {
56051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56052       };
56053     } catch (Dali::DaliException e) {
56054       {
56055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56056       };
56057     } catch (...) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56060       };
56061     }
56062   }
56063
56064 }
56065
56066
56067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56068   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56069   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56070
56071   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56072   arg2 = (void (*)(Dali::Actor))jarg2;
56073   {
56074     try {
56075       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56076     } catch (std::out_of_range& e) {
56077       {
56078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56079       };
56080     } catch (std::exception& e) {
56081       {
56082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56083       };
56084     } catch (Dali::DaliException e) {
56085       {
56086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56087       };
56088     } catch (...) {
56089       {
56090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56091       };
56092     }
56093   }
56094
56095 }
56096
56097
56098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56099   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56100   Dali::Actor arg2 ;
56101   Dali::Actor *argp2 ;
56102
56103   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56104   argp2 = (Dali::Actor *)jarg2;
56105   if (!argp2) {
56106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56107     return ;
56108   }
56109   arg2 = *argp2;
56110   {
56111     try {
56112       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56113     } catch (std::out_of_range& e) {
56114       {
56115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56116       };
56117     } catch (std::exception& e) {
56118       {
56119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56120       };
56121     } catch (Dali::DaliException e) {
56122       {
56123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56124       };
56125     } catch (...) {
56126       {
56127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56128       };
56129     }
56130   }
56131
56132 }
56133
56134
56135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56136   void * jresult ;
56137   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56138
56139   {
56140     try {
56141       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56142     } catch (std::out_of_range& e) {
56143       {
56144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56145       };
56146     } catch (std::exception& e) {
56147       {
56148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56149       };
56150     } catch (Dali::DaliException e) {
56151       {
56152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56153       };
56154     } catch (...) {
56155       {
56156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56157       };
56158     }
56159   }
56160
56161   jresult = (void *)result;
56162   return jresult;
56163 }
56164
56165
56166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56167   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56168
56169   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56170   {
56171     try {
56172       delete arg1;
56173     } catch (std::out_of_range& e) {
56174       {
56175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56176       };
56177     } catch (std::exception& e) {
56178       {
56179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56180       };
56181     } catch (Dali::DaliException e) {
56182       {
56183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56184       };
56185     } catch (...) {
56186       {
56187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56188       };
56189     }
56190   }
56191
56192 }
56193
56194
56195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56196   unsigned int jresult ;
56197   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56198   bool result;
56199
56200   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56201   {
56202     try {
56203       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56204     } catch (std::out_of_range& e) {
56205       {
56206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56207       };
56208     } catch (std::exception& e) {
56209       {
56210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56211       };
56212     } catch (Dali::DaliException e) {
56213       {
56214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56215       };
56216     } catch (...) {
56217       {
56218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56219       };
56220     }
56221   }
56222
56223   jresult = result;
56224   return jresult;
56225 }
56226
56227
56228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56229   unsigned long jresult ;
56230   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56231   std::size_t result;
56232
56233   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56234   {
56235     try {
56236       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56237     } catch (std::out_of_range& e) {
56238       {
56239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (std::exception& e) {
56242       {
56243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (Dali::DaliException e) {
56246       {
56247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56248       };
56249     } catch (...) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56252       };
56253     }
56254   }
56255
56256   jresult = (unsigned long)result;
56257   return jresult;
56258 }
56259
56260
56261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56262   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56263   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56264
56265   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56266   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56267   {
56268     try {
56269       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56270     } catch (std::out_of_range& e) {
56271       {
56272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56273       };
56274     } catch (std::exception& e) {
56275       {
56276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56277       };
56278     } catch (Dali::DaliException e) {
56279       {
56280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56281       };
56282     } catch (...) {
56283       {
56284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56285       };
56286     }
56287   }
56288
56289 }
56290
56291
56292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56293   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56294   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56295
56296   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56297   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56298   {
56299     try {
56300       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56301     } catch (std::out_of_range& e) {
56302       {
56303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56304       };
56305     } catch (std::exception& e) {
56306       {
56307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56308       };
56309     } catch (Dali::DaliException e) {
56310       {
56311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56312       };
56313     } catch (...) {
56314       {
56315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56316       };
56317     }
56318   }
56319
56320 }
56321
56322
56323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56324   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56325   Dali::KeyEvent *arg2 = 0 ;
56326
56327   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56328   arg2 = (Dali::KeyEvent *)jarg2;
56329   if (!arg2) {
56330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56331     return ;
56332   }
56333   {
56334     try {
56335       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56336     } catch (std::out_of_range& e) {
56337       {
56338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56339       };
56340     } catch (std::exception& e) {
56341       {
56342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56343       };
56344     } catch (Dali::DaliException e) {
56345       {
56346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56347       };
56348     } catch (...) {
56349       {
56350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56351       };
56352     }
56353   }
56354
56355 }
56356
56357
56358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56359   void * jresult ;
56360   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56361
56362   {
56363     try {
56364       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56365     } catch (std::out_of_range& e) {
56366       {
56367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (std::exception& e) {
56370       {
56371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56372       };
56373     } catch (Dali::DaliException e) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56376       };
56377     } catch (...) {
56378       {
56379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56380       };
56381     }
56382   }
56383
56384   jresult = (void *)result;
56385   return jresult;
56386 }
56387
56388
56389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56390   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56391
56392   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56393   {
56394     try {
56395       delete arg1;
56396     } catch (std::out_of_range& e) {
56397       {
56398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56399       };
56400     } catch (std::exception& e) {
56401       {
56402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56403       };
56404     } catch (Dali::DaliException e) {
56405       {
56406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56407       };
56408     } catch (...) {
56409       {
56410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56411       };
56412     }
56413   }
56414
56415 }
56416
56417
56418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56419   unsigned int jresult ;
56420   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56421   bool result;
56422
56423   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56424   {
56425     try {
56426       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56427     } catch (std::out_of_range& e) {
56428       {
56429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56430       };
56431     } catch (std::exception& e) {
56432       {
56433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56434       };
56435     } catch (Dali::DaliException e) {
56436       {
56437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56438       };
56439     } catch (...) {
56440       {
56441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56442       };
56443     }
56444   }
56445
56446   jresult = result;
56447   return jresult;
56448 }
56449
56450
56451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56452   unsigned long jresult ;
56453   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56454   std::size_t result;
56455
56456   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56457   {
56458     try {
56459       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56460     } catch (std::out_of_range& e) {
56461       {
56462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56463       };
56464     } catch (std::exception& e) {
56465       {
56466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56467       };
56468     } catch (Dali::DaliException e) {
56469       {
56470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56471       };
56472     } catch (...) {
56473       {
56474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56475       };
56476     }
56477   }
56478
56479   jresult = (unsigned long)result;
56480   return jresult;
56481 }
56482
56483
56484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56485   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56486   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56487
56488   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56489   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56490   {
56491     try {
56492       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56493     } catch (std::out_of_range& e) {
56494       {
56495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56496       };
56497     } catch (std::exception& e) {
56498       {
56499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56500       };
56501     } catch (Dali::DaliException e) {
56502       {
56503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56504       };
56505     } catch (...) {
56506       {
56507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56508       };
56509     }
56510   }
56511
56512 }
56513
56514
56515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56516   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56517   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56518
56519   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56520   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56521   {
56522     try {
56523       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56524     } catch (std::out_of_range& e) {
56525       {
56526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56527       };
56528     } catch (std::exception& e) {
56529       {
56530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56531       };
56532     } catch (Dali::DaliException e) {
56533       {
56534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56535       };
56536     } catch (...) {
56537       {
56538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56539       };
56540     }
56541   }
56542
56543 }
56544
56545
56546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56547   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56548   Dali::TouchData *arg2 = 0 ;
56549
56550   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56551   arg2 = (Dali::TouchData *)jarg2;
56552   if (!arg2) {
56553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56554     return ;
56555   }
56556   {
56557     try {
56558       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56559     } catch (std::out_of_range& e) {
56560       {
56561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56562       };
56563     } catch (std::exception& e) {
56564       {
56565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56566       };
56567     } catch (Dali::DaliException e) {
56568       {
56569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56570       };
56571     } catch (...) {
56572       {
56573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56574       };
56575     }
56576   }
56577
56578 }
56579
56580
56581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56582   void * jresult ;
56583   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56584
56585   {
56586     try {
56587       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56588     } catch (std::out_of_range& e) {
56589       {
56590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56591       };
56592     } catch (std::exception& e) {
56593       {
56594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56595       };
56596     } catch (Dali::DaliException e) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56599       };
56600     } catch (...) {
56601       {
56602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56603       };
56604     }
56605   }
56606
56607   jresult = (void *)result;
56608   return jresult;
56609 }
56610
56611
56612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56613   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56614
56615   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56616   {
56617     try {
56618       delete arg1;
56619     } catch (std::out_of_range& e) {
56620       {
56621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56622       };
56623     } catch (std::exception& e) {
56624       {
56625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56626       };
56627     } catch (Dali::DaliException e) {
56628       {
56629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56630       };
56631     } catch (...) {
56632       {
56633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56634       };
56635     }
56636   }
56637
56638 }
56639
56640
56641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56642   unsigned int jresult ;
56643   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56644   bool result;
56645
56646   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56647   {
56648     try {
56649       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56650     } catch (std::out_of_range& e) {
56651       {
56652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56653       };
56654     } catch (std::exception& e) {
56655       {
56656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56657       };
56658     } catch (Dali::DaliException e) {
56659       {
56660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56661       };
56662     } catch (...) {
56663       {
56664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56665       };
56666     }
56667   }
56668
56669   jresult = result;
56670   return jresult;
56671 }
56672
56673
56674 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56675   unsigned long jresult ;
56676   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56677   std::size_t result;
56678
56679   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56680   {
56681     try {
56682       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56683     } catch (std::out_of_range& e) {
56684       {
56685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56686       };
56687     } catch (std::exception& e) {
56688       {
56689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56690       };
56691     } catch (Dali::DaliException e) {
56692       {
56693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56694       };
56695     } catch (...) {
56696       {
56697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56698       };
56699     }
56700   }
56701
56702   jresult = (unsigned long)result;
56703   return jresult;
56704 }
56705
56706
56707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56708   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56709   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56710
56711   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56712   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56713   {
56714     try {
56715       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56716     } catch (std::out_of_range& e) {
56717       {
56718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56719       };
56720     } catch (std::exception& e) {
56721       {
56722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56723       };
56724     } catch (Dali::DaliException e) {
56725       {
56726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56727       };
56728     } catch (...) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56731       };
56732     }
56733   }
56734
56735 }
56736
56737
56738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56739   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56740   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56741
56742   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56743   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56744   {
56745     try {
56746       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56747     } catch (std::out_of_range& e) {
56748       {
56749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56750       };
56751     } catch (std::exception& e) {
56752       {
56753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56754       };
56755     } catch (Dali::DaliException e) {
56756       {
56757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56758       };
56759     } catch (...) {
56760       {
56761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56762       };
56763     }
56764   }
56765
56766 }
56767
56768
56769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56770   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56771   Dali::WheelEvent *arg2 = 0 ;
56772
56773   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56774   arg2 = (Dali::WheelEvent *)jarg2;
56775   if (!arg2) {
56776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56777     return ;
56778   }
56779   {
56780     try {
56781       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56782     } catch (std::out_of_range& e) {
56783       {
56784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56785       };
56786     } catch (std::exception& e) {
56787       {
56788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56789       };
56790     } catch (Dali::DaliException e) {
56791       {
56792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56793       };
56794     } catch (...) {
56795       {
56796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56797       };
56798     }
56799   }
56800
56801 }
56802
56803
56804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56805   void * jresult ;
56806   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56807
56808   {
56809     try {
56810       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56811     } catch (std::out_of_range& e) {
56812       {
56813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56814       };
56815     } catch (std::exception& e) {
56816       {
56817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56818       };
56819     } catch (Dali::DaliException e) {
56820       {
56821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56822       };
56823     } catch (...) {
56824       {
56825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56826       };
56827     }
56828   }
56829
56830   jresult = (void *)result;
56831   return jresult;
56832 }
56833
56834
56835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56836   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56837
56838   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56839   {
56840     try {
56841       delete arg1;
56842     } catch (std::out_of_range& e) {
56843       {
56844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56845       };
56846     } catch (std::exception& e) {
56847       {
56848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56849       };
56850     } catch (Dali::DaliException e) {
56851       {
56852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56853       };
56854     } catch (...) {
56855       {
56856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56857       };
56858     }
56859   }
56860
56861 }
56862
56863
56864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56865   void * jresult ;
56866   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56867
56868   {
56869     try {
56870       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56871     } catch (std::out_of_range& e) {
56872       {
56873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56874       };
56875     } catch (std::exception& e) {
56876       {
56877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56878       };
56879     } catch (Dali::DaliException e) {
56880       {
56881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56886       };
56887     }
56888   }
56889
56890   jresult = (void *)result;
56891   return jresult;
56892 }
56893
56894
56895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56896   void * jresult ;
56897   Dali::Radian arg1 ;
56898   Dali::Radian arg2 ;
56899   Dali::Radian *argp1 ;
56900   Dali::Radian *argp2 ;
56901   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56902
56903   argp1 = (Dali::Radian *)jarg1;
56904   if (!argp1) {
56905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56906     return 0;
56907   }
56908   arg1 = *argp1;
56909   argp2 = (Dali::Radian *)jarg2;
56910   if (!argp2) {
56911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56912     return 0;
56913   }
56914   arg2 = *argp2;
56915   {
56916     try {
56917       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56918     } catch (std::out_of_range& e) {
56919       {
56920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56921       };
56922     } catch (std::exception& e) {
56923       {
56924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56925       };
56926     } catch (Dali::DaliException e) {
56927       {
56928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56929       };
56930     } catch (...) {
56931       {
56932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56933       };
56934     }
56935   }
56936
56937   jresult = (void *)result;
56938   return jresult;
56939 }
56940
56941
56942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56943   void * jresult ;
56944   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56945   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56946
56947   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56948   if (!arg1) {
56949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56950     return 0;
56951   }
56952   {
56953     try {
56954       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56955     } catch (std::out_of_range& e) {
56956       {
56957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56958       };
56959     } catch (std::exception& e) {
56960       {
56961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56962       };
56963     } catch (Dali::DaliException e) {
56964       {
56965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56966       };
56967     } catch (...) {
56968       {
56969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56970       };
56971     }
56972   }
56973
56974   jresult = (void *)result;
56975   return jresult;
56976 }
56977
56978
56979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56980   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56981   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56982
56983   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56984   arg2 = (Dali::Radian *)jarg2;
56985   if (arg1) (arg1)->first = *arg2;
56986 }
56987
56988
56989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56990   void * jresult ;
56991   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56992   Dali::Radian *result = 0 ;
56993
56994   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56995   result = (Dali::Radian *)& ((arg1)->first);
56996   jresult = (void *)result;
56997   return jresult;
56998 }
56999
57000
57001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57002   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57003   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57004
57005   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57006   arg2 = (Dali::Radian *)jarg2;
57007   if (arg1) (arg1)->second = *arg2;
57008 }
57009
57010
57011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57012   void * jresult ;
57013   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57014   Dali::Radian *result = 0 ;
57015
57016   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57017   result = (Dali::Radian *)& ((arg1)->second);
57018   jresult = (void *)result;
57019   return jresult;
57020 }
57021
57022
57023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57024   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57025
57026   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57027   {
57028     try {
57029       delete arg1;
57030     } catch (std::out_of_range& e) {
57031       {
57032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57033       };
57034     } catch (std::exception& e) {
57035       {
57036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57037       };
57038     } catch (Dali::DaliException e) {
57039       {
57040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57041       };
57042     } catch (...) {
57043       {
57044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57045       };
57046     }
57047   }
57048
57049 }
57050
57051
57052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57053   unsigned int jresult ;
57054   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57055   bool result;
57056
57057   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57058   {
57059     try {
57060       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);
57061     } catch (std::out_of_range& e) {
57062       {
57063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57064       };
57065     } catch (std::exception& e) {
57066       {
57067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57068       };
57069     } catch (Dali::DaliException e) {
57070       {
57071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57072       };
57073     } catch (...) {
57074       {
57075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57076       };
57077     }
57078   }
57079
57080   jresult = result;
57081   return jresult;
57082 }
57083
57084
57085 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57086   unsigned long jresult ;
57087   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57088   std::size_t result;
57089
57090   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57091   {
57092     try {
57093       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);
57094     } catch (std::out_of_range& e) {
57095       {
57096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57097       };
57098     } catch (std::exception& e) {
57099       {
57100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57101       };
57102     } catch (Dali::DaliException e) {
57103       {
57104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57105       };
57106     } catch (...) {
57107       {
57108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57109       };
57110     }
57111   }
57112
57113   jresult = (unsigned long)result;
57114   return jresult;
57115 }
57116
57117
57118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57119   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57120   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57121
57122   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57123   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57124   {
57125     try {
57126       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57127     } catch (std::out_of_range& e) {
57128       {
57129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57130       };
57131     } catch (std::exception& e) {
57132       {
57133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57134       };
57135     } catch (Dali::DaliException e) {
57136       {
57137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57138       };
57139     } catch (...) {
57140       {
57141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57142       };
57143     }
57144   }
57145
57146 }
57147
57148
57149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57150   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57151   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57152
57153   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57154   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57155   {
57156     try {
57157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57158     } catch (std::out_of_range& e) {
57159       {
57160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57161       };
57162     } catch (std::exception& e) {
57163       {
57164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57165       };
57166     } catch (Dali::DaliException e) {
57167       {
57168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57169       };
57170     } catch (...) {
57171       {
57172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57173       };
57174     }
57175   }
57176
57177 }
57178
57179
57180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57181   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57182   Dali::Actor arg2 ;
57183   Dali::PanGesture *arg3 = 0 ;
57184   Dali::Actor *argp2 ;
57185
57186   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57187   argp2 = (Dali::Actor *)jarg2;
57188   if (!argp2) {
57189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57190     return ;
57191   }
57192   arg2 = *argp2;
57193   arg3 = (Dali::PanGesture *)jarg3;
57194   if (!arg3) {
57195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57196     return ;
57197   }
57198   {
57199     try {
57200       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57201     } catch (std::out_of_range& e) {
57202       {
57203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57204       };
57205     } catch (std::exception& e) {
57206       {
57207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57208       };
57209     } catch (Dali::DaliException e) {
57210       {
57211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57212       };
57213     } catch (...) {
57214       {
57215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57216       };
57217     }
57218   }
57219
57220 }
57221
57222
57223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57224   void * jresult ;
57225   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57226
57227   {
57228     try {
57229       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57230     } catch (std::out_of_range& e) {
57231       {
57232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57233       };
57234     } catch (std::exception& e) {
57235       {
57236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57237       };
57238     } catch (Dali::DaliException e) {
57239       {
57240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57241       };
57242     } catch (...) {
57243       {
57244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57245       };
57246     }
57247   }
57248
57249   jresult = (void *)result;
57250   return jresult;
57251 }
57252
57253
57254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57255   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57256
57257   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57258   {
57259     try {
57260       delete arg1;
57261     } catch (std::out_of_range& e) {
57262       {
57263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57264       };
57265     } catch (std::exception& e) {
57266       {
57267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57268       };
57269     } catch (Dali::DaliException e) {
57270       {
57271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57272       };
57273     } catch (...) {
57274       {
57275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57276       };
57277     }
57278   }
57279
57280 }
57281
57282
57283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57284   unsigned int jresult ;
57285   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57286   bool result;
57287
57288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57289   {
57290     try {
57291       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);
57292     } catch (std::out_of_range& e) {
57293       {
57294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57295       };
57296     } catch (std::exception& e) {
57297       {
57298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57299       };
57300     } catch (Dali::DaliException e) {
57301       {
57302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57303       };
57304     } catch (...) {
57305       {
57306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57307       };
57308     }
57309   }
57310
57311   jresult = result;
57312   return jresult;
57313 }
57314
57315
57316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57317   unsigned long jresult ;
57318   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57319   std::size_t result;
57320
57321   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57322   {
57323     try {
57324       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);
57325     } catch (std::out_of_range& e) {
57326       {
57327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57328       };
57329     } catch (std::exception& e) {
57330       {
57331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57332       };
57333     } catch (Dali::DaliException e) {
57334       {
57335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57336       };
57337     } catch (...) {
57338       {
57339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57340       };
57341     }
57342   }
57343
57344   jresult = (unsigned long)result;
57345   return jresult;
57346 }
57347
57348
57349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57350   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57351   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57352
57353   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57354   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57355   {
57356     try {
57357       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57358     } catch (std::out_of_range& e) {
57359       {
57360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57361       };
57362     } catch (std::exception& e) {
57363       {
57364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57365       };
57366     } catch (Dali::DaliException e) {
57367       {
57368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57369       };
57370     } catch (...) {
57371       {
57372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57373       };
57374     }
57375   }
57376
57377 }
57378
57379
57380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57381   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57382   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57383
57384   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57385   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57386   {
57387     try {
57388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57389     } catch (std::out_of_range& e) {
57390       {
57391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57392       };
57393     } catch (std::exception& e) {
57394       {
57395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57396       };
57397     } catch (Dali::DaliException e) {
57398       {
57399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57400       };
57401     } catch (...) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57404       };
57405     }
57406   }
57407
57408 }
57409
57410
57411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57412   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57413   Dali::Actor arg2 ;
57414   Dali::PinchGesture *arg3 = 0 ;
57415   Dali::Actor *argp2 ;
57416
57417   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57418   argp2 = (Dali::Actor *)jarg2;
57419   if (!argp2) {
57420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57421     return ;
57422   }
57423   arg2 = *argp2;
57424   arg3 = (Dali::PinchGesture *)jarg3;
57425   if (!arg3) {
57426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57427     return ;
57428   }
57429   {
57430     try {
57431       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57432     } catch (std::out_of_range& e) {
57433       {
57434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57435       };
57436     } catch (std::exception& e) {
57437       {
57438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57439       };
57440     } catch (Dali::DaliException e) {
57441       {
57442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57443       };
57444     } catch (...) {
57445       {
57446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57447       };
57448     }
57449   }
57450
57451 }
57452
57453
57454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57455   void * jresult ;
57456   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57457
57458   {
57459     try {
57460       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57461     } catch (std::out_of_range& e) {
57462       {
57463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57464       };
57465     } catch (std::exception& e) {
57466       {
57467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57468       };
57469     } catch (Dali::DaliException e) {
57470       {
57471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57472       };
57473     } catch (...) {
57474       {
57475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57476       };
57477     }
57478   }
57479
57480   jresult = (void *)result;
57481   return jresult;
57482 }
57483
57484
57485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57486   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57487
57488   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57489   {
57490     try {
57491       delete arg1;
57492     } catch (std::out_of_range& e) {
57493       {
57494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57495       };
57496     } catch (std::exception& e) {
57497       {
57498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57499       };
57500     } catch (Dali::DaliException e) {
57501       {
57502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57503       };
57504     } catch (...) {
57505       {
57506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57507       };
57508     }
57509   }
57510
57511 }
57512
57513
57514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57515   unsigned int jresult ;
57516   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57517   bool result;
57518
57519   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57520   {
57521     try {
57522       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);
57523     } catch (std::out_of_range& e) {
57524       {
57525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57526       };
57527     } catch (std::exception& e) {
57528       {
57529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57530       };
57531     } catch (Dali::DaliException e) {
57532       {
57533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57534       };
57535     } catch (...) {
57536       {
57537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57538       };
57539     }
57540   }
57541
57542   jresult = result;
57543   return jresult;
57544 }
57545
57546
57547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57548   unsigned long jresult ;
57549   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57550   std::size_t result;
57551
57552   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57553   {
57554     try {
57555       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);
57556     } catch (std::out_of_range& e) {
57557       {
57558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57559       };
57560     } catch (std::exception& e) {
57561       {
57562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57563       };
57564     } catch (Dali::DaliException e) {
57565       {
57566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57567       };
57568     } catch (...) {
57569       {
57570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57571       };
57572     }
57573   }
57574
57575   jresult = (unsigned long)result;
57576   return jresult;
57577 }
57578
57579
57580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57581   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57582   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57583
57584   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57585   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57586   {
57587     try {
57588       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57589     } catch (std::out_of_range& e) {
57590       {
57591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57592       };
57593     } catch (std::exception& e) {
57594       {
57595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57596       };
57597     } catch (Dali::DaliException e) {
57598       {
57599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57600       };
57601     } catch (...) {
57602       {
57603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57604       };
57605     }
57606   }
57607
57608 }
57609
57610
57611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57612   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57613   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57614
57615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57616   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57617   {
57618     try {
57619       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57620     } catch (std::out_of_range& e) {
57621       {
57622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57623       };
57624     } catch (std::exception& e) {
57625       {
57626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57627       };
57628     } catch (Dali::DaliException e) {
57629       {
57630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57631       };
57632     } catch (...) {
57633       {
57634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57635       };
57636     }
57637   }
57638
57639 }
57640
57641
57642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57643   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57644   Dali::Actor arg2 ;
57645   Dali::TapGesture *arg3 = 0 ;
57646   Dali::Actor *argp2 ;
57647
57648   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57649   argp2 = (Dali::Actor *)jarg2;
57650   if (!argp2) {
57651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57652     return ;
57653   }
57654   arg2 = *argp2;
57655   arg3 = (Dali::TapGesture *)jarg3;
57656   if (!arg3) {
57657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57658     return ;
57659   }
57660   {
57661     try {
57662       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57663     } catch (std::out_of_range& e) {
57664       {
57665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57666       };
57667     } catch (std::exception& e) {
57668       {
57669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57670       };
57671     } catch (Dali::DaliException e) {
57672       {
57673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57674       };
57675     } catch (...) {
57676       {
57677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57678       };
57679     }
57680   }
57681
57682 }
57683
57684
57685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57686   void * jresult ;
57687   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57688
57689   {
57690     try {
57691       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57692     } catch (std::out_of_range& e) {
57693       {
57694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57695       };
57696     } catch (std::exception& e) {
57697       {
57698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57699       };
57700     } catch (Dali::DaliException e) {
57701       {
57702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57703       };
57704     } catch (...) {
57705       {
57706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57707       };
57708     }
57709   }
57710
57711   jresult = (void *)result;
57712   return jresult;
57713 }
57714
57715
57716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57717   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57718
57719   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57720   {
57721     try {
57722       delete arg1;
57723     } catch (std::out_of_range& e) {
57724       {
57725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57726       };
57727     } catch (std::exception& e) {
57728       {
57729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57730       };
57731     } catch (Dali::DaliException e) {
57732       {
57733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57734       };
57735     } catch (...) {
57736       {
57737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57738       };
57739     }
57740   }
57741
57742 }
57743
57744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57745   unsigned int jresult ;
57746   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57747   bool result;
57748
57749   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57750   {
57751     try {
57752       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57753     } catch (std::out_of_range& e) {
57754       {
57755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57756       };
57757     } catch (std::exception& e) {
57758       {
57759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57760       };
57761     } catch (Dali::DaliException e) {
57762       {
57763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57764       };
57765     } catch (...) {
57766       {
57767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57768       };
57769     }
57770   }
57771
57772   jresult = result;
57773   return jresult;
57774 }
57775
57776
57777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57778   unsigned long jresult ;
57779   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57780   std::size_t result;
57781
57782   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57783   {
57784     try {
57785       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57786     } catch (std::out_of_range& e) {
57787       {
57788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57789       };
57790     } catch (std::exception& e) {
57791       {
57792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57793       };
57794     } catch (Dali::DaliException e) {
57795       {
57796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57797       };
57798     } catch (...) {
57799       {
57800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57801       };
57802     }
57803   }
57804
57805   jresult = (unsigned long)result;
57806   return jresult;
57807 }
57808
57809
57810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57811   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57812   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57813
57814   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57815   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57816   {
57817     try {
57818       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57819     } catch (std::out_of_range& e) {
57820       {
57821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57822       };
57823     } catch (std::exception& e) {
57824       {
57825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57826       };
57827     } catch (Dali::DaliException e) {
57828       {
57829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57830       };
57831     } catch (...) {
57832       {
57833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57834       };
57835     }
57836   }
57837
57838 }
57839
57840
57841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57842   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57843   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57844
57845   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57846   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57847   {
57848     try {
57849       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57850     } catch (std::out_of_range& e) {
57851       {
57852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57853       };
57854     } catch (std::exception& e) {
57855       {
57856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57857       };
57858     } catch (Dali::DaliException e) {
57859       {
57860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57861       };
57862     } catch (...) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57865       };
57866     }
57867   }
57868
57869 }
57870
57871
57872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57873   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57874   Dali::ResourceImage arg2 ;
57875   Dali::ResourceImage *argp2 ;
57876
57877   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57878   argp2 = (Dali::ResourceImage *)jarg2;
57879   if (!argp2) {
57880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57881     return ;
57882   }
57883   arg2 = *argp2;
57884   {
57885     try {
57886       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57887     } catch (std::out_of_range& e) {
57888       {
57889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57890       };
57891     } catch (std::exception& e) {
57892       {
57893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57894       };
57895     } catch (Dali::DaliException e) {
57896       {
57897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57898       };
57899     } catch (...) {
57900       {
57901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57902       };
57903     }
57904   }
57905
57906 }
57907
57908
57909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57910   void * jresult ;
57911   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57912
57913   {
57914     try {
57915       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57916     } catch (std::out_of_range& e) {
57917       {
57918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57919       };
57920     } catch (std::exception& e) {
57921       {
57922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57923       };
57924     } catch (Dali::DaliException e) {
57925       {
57926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57927       };
57928     } catch (...) {
57929       {
57930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57931       };
57932     }
57933   }
57934
57935   jresult = (void *)result;
57936   return jresult;
57937 }
57938
57939
57940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57941   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57942
57943   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57944   {
57945     try {
57946       delete arg1;
57947     } catch (std::out_of_range& e) {
57948       {
57949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57950       };
57951     } catch (std::exception& e) {
57952       {
57953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57954       };
57955     } catch (Dali::DaliException e) {
57956       {
57957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57958       };
57959     } catch (...) {
57960       {
57961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57962       };
57963     }
57964   }
57965
57966 }
57967
57968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57969   unsigned int jresult ;
57970   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57971   bool result = false;
57972
57973   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57974   {
57975     try {
57976       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);
57977     } catch (std::out_of_range& e) {
57978       {
57979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57980       };
57981     } catch (std::exception& e) {
57982       {
57983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57984       };
57985     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57986   }
57987   jresult = result;
57988   return jresult;
57989 }
57990
57991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57992   unsigned long jresult ;
57993   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57994   std::size_t result = 0;
57995
57996   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57997   {
57998     try {
57999       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);
58000     } catch (std::out_of_range& e) {
58001       {
58002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58003       };
58004     } catch (std::exception& e) {
58005       {
58006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58007       };
58008     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58009   }
58010   jresult = (unsigned long)result;
58011   return jresult;
58012 }
58013
58014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58015   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58016   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58017
58018   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58019   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58020   {
58021     try {
58022       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58023     } catch (std::out_of_range& e) {
58024       {
58025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58026       };
58027     } catch (std::exception& e) {
58028       {
58029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58030       };
58031     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58032   }
58033 }
58034
58035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58036   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58037   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58038
58039   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58040   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58041   {
58042     try {
58043       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58044     } catch (std::out_of_range& e) {
58045       {
58046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58047       };
58048     } catch (std::exception& e) {
58049       {
58050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58051       };
58052     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58053   }
58054 }
58055
58056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58057   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58058   Dali::Actor arg2 ;
58059   //bool arg3 ;
58060   Dali::LayoutDirection::Type arg4 ;
58061   Dali::Actor *argp2 ;
58062
58063   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58064   argp2 = (Dali::Actor *)jarg2;
58065   if (!argp2) {
58066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58067     return ;
58068   }
58069   arg2 = *argp2;
58070   //arg3 = jarg3 ? true : false;
58071   arg4 = (Dali::LayoutDirection::Type)jarg4;
58072   {
58073     try {
58074       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58075     } catch (std::out_of_range& e) {
58076       {
58077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58078       };
58079     } catch (std::exception& e) {
58080       {
58081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58082       };
58083     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58084   }
58085 }
58086
58087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58088   void * jresult ;
58089   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58090
58091   {
58092     try {
58093       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58094     } catch (std::out_of_range& e) {
58095       {
58096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58097       };
58098     } catch (std::exception& e) {
58099       {
58100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58101       };
58102     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58103   }
58104   jresult = (void *)result;
58105   return jresult;
58106 }
58107
58108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58109   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58110
58111   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58112   {
58113     try {
58114       delete arg1;
58115     } catch (std::out_of_range& e) {
58116       {
58117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58118       };
58119     } catch (std::exception& e) {
58120       {
58121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58122       };
58123     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58124   }
58125 }
58126
58127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58128   unsigned int jresult ;
58129   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58130   bool result;
58131
58132   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58133   {
58134     try {
58135       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);
58136     } catch (std::out_of_range& e) {
58137       {
58138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58139       };
58140     } catch (std::exception& e) {
58141       {
58142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58143       };
58144     } catch (Dali::DaliException e) {
58145       {
58146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58147       };
58148     } catch (...) {
58149       {
58150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58151       };
58152     }
58153   }
58154
58155   jresult = result;
58156   return jresult;
58157 }
58158
58159
58160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58161   unsigned long jresult ;
58162   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58163   std::size_t result;
58164
58165   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58166   {
58167     try {
58168       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);
58169     } catch (std::out_of_range& e) {
58170       {
58171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58172       };
58173     } catch (std::exception& e) {
58174       {
58175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58176       };
58177     } catch (Dali::DaliException e) {
58178       {
58179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58180       };
58181     } catch (...) {
58182       {
58183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58184       };
58185     }
58186   }
58187
58188   jresult = (unsigned long)result;
58189   return jresult;
58190 }
58191
58192
58193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58194   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58195   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58196
58197   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58198   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58199   {
58200     try {
58201       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58202     } catch (std::out_of_range& e) {
58203       {
58204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58205       };
58206     } catch (std::exception& e) {
58207       {
58208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58209       };
58210     } catch (Dali::DaliException e) {
58211       {
58212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58213       };
58214     } catch (...) {
58215       {
58216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58217       };
58218     }
58219   }
58220
58221 }
58222
58223
58224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58225   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58226   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58227
58228   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58229   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58230   {
58231     try {
58232       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58233     } catch (std::out_of_range& e) {
58234       {
58235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58236       };
58237     } catch (std::exception& e) {
58238       {
58239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58240       };
58241     } catch (Dali::DaliException e) {
58242       {
58243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58244       };
58245     } catch (...) {
58246       {
58247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58248       };
58249     }
58250   }
58251
58252 }
58253
58254
58255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58256   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58257   Dali::Actor arg2 ;
58258   bool arg3 ;
58259   Dali::DevelActor::VisibilityChange::Type arg4 ;
58260   Dali::Actor *argp2 ;
58261
58262   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58263   argp2 = (Dali::Actor *)jarg2;
58264   if (!argp2) {
58265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58266     return ;
58267   }
58268   arg2 = *argp2;
58269   arg3 = jarg3 ? true : false;
58270   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58271   {
58272     try {
58273       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58274     } catch (std::out_of_range& e) {
58275       {
58276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58277       };
58278     } catch (std::exception& e) {
58279       {
58280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58281       };
58282     } catch (Dali::DaliException e) {
58283       {
58284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58285       };
58286     } catch (...) {
58287       {
58288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58289       };
58290     }
58291   }
58292
58293 }
58294
58295
58296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58297   void * jresult ;
58298   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58299
58300   {
58301     try {
58302       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58303     } catch (std::out_of_range& e) {
58304       {
58305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58306       };
58307     } catch (std::exception& e) {
58308       {
58309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (Dali::DaliException e) {
58312       {
58313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58314       };
58315     } catch (...) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58318       };
58319     }
58320   }
58321
58322   jresult = (void *)result;
58323   return jresult;
58324 }
58325
58326
58327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58328   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58329
58330   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58331   {
58332     try {
58333       delete arg1;
58334     } catch (std::out_of_range& e) {
58335       {
58336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58337       };
58338     } catch (std::exception& e) {
58339       {
58340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58341       };
58342     } catch (Dali::DaliException e) {
58343       {
58344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58345       };
58346     } catch (...) {
58347       {
58348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58349       };
58350     }
58351   }
58352
58353 }
58354
58355
58356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58357   void * jresult ;
58358   Dali::Timer *result = 0 ;
58359
58360   {
58361     try {
58362       result = (Dali::Timer *)new Dali::Timer();
58363     } catch (std::out_of_range& e) {
58364       {
58365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58366       };
58367     } catch (std::exception& e) {
58368       {
58369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58370       };
58371     } catch (Dali::DaliException e) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58374       };
58375     } catch (...) {
58376       {
58377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58378       };
58379     }
58380   }
58381
58382   jresult = (void *)result;
58383   return jresult;
58384 }
58385
58386
58387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58388   void * jresult ;
58389   unsigned int arg1 ;
58390   Dali::Timer result;
58391
58392   arg1 = (unsigned int)jarg1;
58393   {
58394     try {
58395       result = Dali::Timer::New(arg1);
58396     } catch (std::out_of_range& e) {
58397       {
58398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58399       };
58400     } catch (std::exception& e) {
58401       {
58402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58403       };
58404     } catch (Dali::DaliException e) {
58405       {
58406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58407       };
58408     } catch (...) {
58409       {
58410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58411       };
58412     }
58413   }
58414
58415   jresult = new Dali::Timer((const Dali::Timer &)result);
58416   return jresult;
58417 }
58418
58419
58420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58421   void * jresult ;
58422   Dali::Timer *arg1 = 0 ;
58423   Dali::Timer *result = 0 ;
58424
58425   arg1 = (Dali::Timer *)jarg1;
58426   if (!arg1) {
58427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58428     return 0;
58429   }
58430   {
58431     try {
58432       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58433     } catch (std::out_of_range& e) {
58434       {
58435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58436       };
58437     } catch (std::exception& e) {
58438       {
58439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58440       };
58441     } catch (Dali::DaliException e) {
58442       {
58443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58444       };
58445     } catch (...) {
58446       {
58447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58448       };
58449     }
58450   }
58451
58452   jresult = (void *)result;
58453   return jresult;
58454 }
58455
58456
58457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58458   void * jresult ;
58459   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58460   Dali::Timer *arg2 = 0 ;
58461   Dali::Timer *result = 0 ;
58462
58463   arg1 = (Dali::Timer *)jarg1;
58464   arg2 = (Dali::Timer *)jarg2;
58465   if (!arg2) {
58466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58467     return 0;
58468   }
58469   {
58470     try {
58471       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58472     } catch (std::out_of_range& e) {
58473       {
58474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58475       };
58476     } catch (std::exception& e) {
58477       {
58478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58479       };
58480     } catch (Dali::DaliException e) {
58481       {
58482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58483       };
58484     } catch (...) {
58485       {
58486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58487       };
58488     }
58489   }
58490
58491   jresult = (void *)result;
58492   return jresult;
58493 }
58494
58495
58496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58497   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58498
58499   arg1 = (Dali::Timer *)jarg1;
58500   {
58501     try {
58502       delete arg1;
58503     } catch (std::out_of_range& e) {
58504       {
58505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58506       };
58507     } catch (std::exception& e) {
58508       {
58509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58510       };
58511     } catch (Dali::DaliException e) {
58512       {
58513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58514       };
58515     } catch (...) {
58516       {
58517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58518       };
58519     }
58520   }
58521
58522 }
58523
58524
58525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58526   void * jresult ;
58527   Dali::BaseHandle arg1 ;
58528   Dali::BaseHandle *argp1 ;
58529   Dali::Timer result;
58530
58531   argp1 = (Dali::BaseHandle *)jarg1;
58532   if (!argp1) {
58533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58534     return 0;
58535   }
58536   arg1 = *argp1;
58537   {
58538     try {
58539       result = Dali::Timer::DownCast(arg1);
58540     } catch (std::out_of_range& e) {
58541       {
58542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58543       };
58544     } catch (std::exception& e) {
58545       {
58546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58547       };
58548     } catch (Dali::DaliException e) {
58549       {
58550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58551       };
58552     } catch (...) {
58553       {
58554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58555       };
58556     }
58557   }
58558
58559   jresult = new Dali::Timer((const Dali::Timer &)result);
58560   return jresult;
58561 }
58562
58563
58564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58565   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58566
58567   arg1 = (Dali::Timer *)jarg1;
58568   {
58569     try {
58570       (arg1)->Start();
58571     } catch (std::out_of_range& e) {
58572       {
58573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58574       };
58575     } catch (std::exception& e) {
58576       {
58577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58578       };
58579     } catch (Dali::DaliException e) {
58580       {
58581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58582       };
58583     } catch (...) {
58584       {
58585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58586       };
58587     }
58588   }
58589
58590 }
58591
58592
58593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58594   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58595
58596   arg1 = (Dali::Timer *)jarg1;
58597   {
58598     try {
58599       (arg1)->Stop();
58600     } catch (std::out_of_range& e) {
58601       {
58602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58603       };
58604     } catch (std::exception& e) {
58605       {
58606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58607       };
58608     } catch (Dali::DaliException e) {
58609       {
58610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58611       };
58612     } catch (...) {
58613       {
58614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58615       };
58616     }
58617   }
58618
58619 }
58620
58621
58622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58623   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58624   unsigned int arg2 ;
58625
58626   arg1 = (Dali::Timer *)jarg1;
58627   arg2 = (unsigned int)jarg2;
58628   {
58629     try {
58630       (arg1)->SetInterval(arg2);
58631     } catch (std::out_of_range& e) {
58632       {
58633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58634       };
58635     } catch (std::exception& e) {
58636       {
58637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58638       };
58639     } catch (Dali::DaliException e) {
58640       {
58641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58642       };
58643     } catch (...) {
58644       {
58645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58646       };
58647     }
58648   }
58649
58650 }
58651
58652
58653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58654   unsigned int jresult ;
58655   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58656   unsigned int result;
58657
58658   arg1 = (Dali::Timer *)jarg1;
58659   {
58660     try {
58661       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58662     } catch (std::out_of_range& e) {
58663       {
58664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58665       };
58666     } catch (std::exception& e) {
58667       {
58668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58669       };
58670     } catch (Dali::DaliException e) {
58671       {
58672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58673       };
58674     } catch (...) {
58675       {
58676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58677       };
58678     }
58679   }
58680
58681   jresult = result;
58682   return jresult;
58683 }
58684
58685
58686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58687   unsigned int jresult ;
58688   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58689   bool result;
58690
58691   arg1 = (Dali::Timer *)jarg1;
58692   {
58693     try {
58694       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58695     } catch (std::out_of_range& e) {
58696       {
58697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (std::exception& e) {
58700       {
58701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58702       };
58703     } catch (Dali::DaliException e) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58706       };
58707     } catch (...) {
58708       {
58709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58710       };
58711     }
58712   }
58713
58714   jresult = result;
58715   return jresult;
58716 }
58717
58718
58719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58720   void * jresult ;
58721   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58722   Dali::Timer::TimerSignalType *result = 0 ;
58723
58724   arg1 = (Dali::Timer *)jarg1;
58725   {
58726     try {
58727       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58728     } catch (std::out_of_range& e) {
58729       {
58730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58731       };
58732     } catch (std::exception& e) {
58733       {
58734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58735       };
58736     } catch (Dali::DaliException e) {
58737       {
58738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58739       };
58740     } catch (...) {
58741       {
58742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58743       };
58744     }
58745   }
58746
58747   jresult = (void *)result;
58748   return jresult;
58749 }
58750
58751
58752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58753   void * jresult ;
58754   Dali::DragAndDropDetector *result = 0 ;
58755
58756   {
58757     try {
58758       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58759     } catch (std::out_of_range& e) {
58760       {
58761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58762       };
58763     } catch (std::exception& e) {
58764       {
58765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58766       };
58767     } catch (Dali::DaliException e) {
58768       {
58769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58770       };
58771     } catch (...) {
58772       {
58773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58774       };
58775     }
58776   }
58777
58778   jresult = (void *)result;
58779   return jresult;
58780 }
58781
58782
58783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58784   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58785
58786   arg1 = (Dali::DragAndDropDetector *)jarg1;
58787   {
58788     try {
58789       delete arg1;
58790     } catch (std::out_of_range& e) {
58791       {
58792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58793       };
58794     } catch (std::exception& e) {
58795       {
58796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58797       };
58798     } catch (Dali::DaliException e) {
58799       {
58800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58801       };
58802     } catch (...) {
58803       {
58804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58805       };
58806     }
58807   }
58808
58809 }
58810
58811
58812 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58813   char * jresult ;
58814   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58815   std::string *result = 0 ;
58816
58817   arg1 = (Dali::DragAndDropDetector *)jarg1;
58818   {
58819     try {
58820       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58821     } catch (std::out_of_range& e) {
58822       {
58823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (std::exception& e) {
58826       {
58827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58828       };
58829     } catch (Dali::DaliException e) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58832       };
58833     } catch (...) {
58834       {
58835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58836       };
58837     }
58838   }
58839
58840   jresult = SWIG_csharp_string_callback(result->c_str());
58841   return jresult;
58842 }
58843
58844
58845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58846   void * jresult ;
58847   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58848   Dali::Vector2 result;
58849
58850   arg1 = (Dali::DragAndDropDetector *)jarg1;
58851   {
58852     try {
58853       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58854     } catch (std::out_of_range& e) {
58855       {
58856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58857       };
58858     } catch (std::exception& e) {
58859       {
58860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58861       };
58862     } catch (Dali::DaliException e) {
58863       {
58864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58865       };
58866     } catch (...) {
58867       {
58868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58869       };
58870     }
58871   }
58872
58873   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58874   return jresult;
58875 }
58876
58877
58878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58879   void * jresult ;
58880   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58881   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58882
58883   arg1 = (Dali::DragAndDropDetector *)jarg1;
58884   {
58885     try {
58886       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58887     } catch (std::out_of_range& e) {
58888       {
58889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (std::exception& e) {
58892       {
58893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58894       };
58895     } catch (Dali::DaliException e) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58898       };
58899     } catch (...) {
58900       {
58901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58902       };
58903     }
58904   }
58905
58906   jresult = (void *)result;
58907   return jresult;
58908 }
58909
58910
58911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58912   void * jresult ;
58913   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58914   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58915
58916   arg1 = (Dali::DragAndDropDetector *)jarg1;
58917   {
58918     try {
58919       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58920     } catch (std::out_of_range& e) {
58921       {
58922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58923       };
58924     } catch (std::exception& e) {
58925       {
58926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58927       };
58928     } catch (Dali::DaliException e) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58931       };
58932     } catch (...) {
58933       {
58934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58935       };
58936     }
58937   }
58938
58939   jresult = (void *)result;
58940   return jresult;
58941 }
58942
58943
58944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58945   void * jresult ;
58946   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58947   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58948
58949   arg1 = (Dali::DragAndDropDetector *)jarg1;
58950   {
58951     try {
58952       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58953     } catch (std::out_of_range& e) {
58954       {
58955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58956       };
58957     } catch (std::exception& e) {
58958       {
58959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58960       };
58961     } catch (Dali::DaliException e) {
58962       {
58963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58964       };
58965     } catch (...) {
58966       {
58967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58968       };
58969     }
58970   }
58971
58972   jresult = (void *)result;
58973   return jresult;
58974 }
58975
58976
58977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58978   void * jresult ;
58979   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58980   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58981
58982   arg1 = (Dali::DragAndDropDetector *)jarg1;
58983   {
58984     try {
58985       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58986     } catch (std::out_of_range& e) {
58987       {
58988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58989       };
58990     } catch (std::exception& e) {
58991       {
58992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58993       };
58994     } catch (Dali::DaliException e) {
58995       {
58996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58997       };
58998     } catch (...) {
58999       {
59000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59001       };
59002     }
59003   }
59004
59005   jresult = (void *)result;
59006   return jresult;
59007 }
59008
59009
59010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59011   void * jresult ;
59012   Dali::ApplicationExtensions *result = 0 ;
59013
59014   {
59015     try {
59016       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59017     } catch (std::out_of_range& e) {
59018       {
59019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (std::exception& e) {
59022       {
59023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59024       };
59025     } catch (Dali::DaliException e) {
59026       {
59027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59028       };
59029     } catch (...) {
59030       {
59031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59032       };
59033     }
59034   }
59035
59036   jresult = (void *)result;
59037   return jresult;
59038 }
59039
59040
59041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59042   void * jresult ;
59043   Dali::Application *arg1 = (Dali::Application *) 0 ;
59044   Dali::ApplicationExtensions *result = 0 ;
59045
59046   arg1 = (Dali::Application *)jarg1;
59047   {
59048     try {
59049       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59050     } catch (std::out_of_range& e) {
59051       {
59052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59053       };
59054     } catch (std::exception& e) {
59055       {
59056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59057       };
59058     } catch (Dali::DaliException e) {
59059       {
59060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59061       };
59062     } catch (...) {
59063       {
59064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59065       };
59066     }
59067   }
59068
59069   jresult = (void *)result;
59070   return jresult;
59071 }
59072
59073
59074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59075   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59076
59077   arg1 = (Dali::ApplicationExtensions *)jarg1;
59078   {
59079     try {
59080       delete arg1;
59081     } catch (std::out_of_range& e) {
59082       {
59083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59084       };
59085     } catch (std::exception& e) {
59086       {
59087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59088       };
59089     } catch (Dali::DaliException e) {
59090       {
59091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59092       };
59093     } catch (...) {
59094       {
59095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59096       };
59097     }
59098   }
59099
59100 }
59101
59102
59103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59104   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59105
59106   arg1 = (Dali::ApplicationExtensions *)jarg1;
59107   {
59108     try {
59109       (arg1)->Init();
59110     } catch (std::out_of_range& e) {
59111       {
59112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59113       };
59114     } catch (std::exception& e) {
59115       {
59116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59117       };
59118     } catch (Dali::DaliException e) {
59119       {
59120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59121       };
59122     } catch (...) {
59123       {
59124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59125       };
59126     }
59127   }
59128
59129 }
59130
59131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59132   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59133
59134   arg1 = (Dali::ApplicationExtensions *)jarg1;
59135   {
59136     try {
59137       (arg1)->Start();
59138     } catch (std::out_of_range& e) {
59139       {
59140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59141       };
59142     } catch (std::exception& e) {
59143       {
59144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59145       };
59146     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59147   }
59148 }
59149
59150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59151   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59152
59153   arg1 = (Dali::ApplicationExtensions *)jarg1;
59154   {
59155     try {
59156       (arg1)->Terminate();
59157     } catch (std::out_of_range& e) {
59158       {
59159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59160       };
59161     } catch (std::exception& e) {
59162       {
59163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59164       };
59165     } catch (Dali::DaliException e) {
59166       {
59167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59168       };
59169     } catch (...) {
59170       {
59171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59172       };
59173     }
59174   }
59175
59176 }
59177
59178
59179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59180   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59181
59182   arg1 = (Dali::ApplicationExtensions *)jarg1;
59183   {
59184     try {
59185       (arg1)->Pause();
59186     } catch (std::out_of_range& e) {
59187       {
59188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59189       };
59190     } catch (std::exception& e) {
59191       {
59192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59193       };
59194     } catch (Dali::DaliException e) {
59195       {
59196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59197       };
59198     } catch (...) {
59199       {
59200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59201       };
59202     }
59203   }
59204
59205 }
59206
59207
59208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59209   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59210
59211   arg1 = (Dali::ApplicationExtensions *)jarg1;
59212   {
59213     try {
59214       (arg1)->Resume();
59215     } catch (std::out_of_range& e) {
59216       {
59217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59218       };
59219     } catch (std::exception& e) {
59220       {
59221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59222       };
59223     } catch (Dali::DaliException e) {
59224       {
59225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59226       };
59227     } catch (...) {
59228       {
59229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59230       };
59231     }
59232   }
59233
59234 }
59235
59236
59237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59238   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59239
59240   arg1 = (Dali::ApplicationExtensions *)jarg1;
59241   {
59242     try {
59243       (arg1)->LanguageChange();
59244     } catch (std::out_of_range& e) {
59245       {
59246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59247       };
59248     } catch (std::exception& e) {
59249       {
59250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59251       };
59252     } catch (Dali::DaliException e) {
59253       {
59254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59255       };
59256     } catch (...) {
59257       {
59258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59259       };
59260     }
59261   }
59262
59263 }
59264
59265
59266
59267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59268   unsigned int jresult ;
59269   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59270   bool result;
59271
59272   arg1 = (Dali::Signal< bool () > *)jarg1;
59273   {
59274     try {
59275       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59276     } catch (std::out_of_range& e) {
59277       {
59278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59279       };
59280     } catch (std::exception& e) {
59281       {
59282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59283       };
59284     } catch (Dali::DaliException e) {
59285       {
59286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59287       };
59288     } catch (...) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59291       };
59292     }
59293   }
59294
59295   jresult = result;
59296   return jresult;
59297 }
59298
59299
59300 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59301   unsigned long jresult ;
59302   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59303   std::size_t result;
59304
59305   arg1 = (Dali::Signal< bool () > *)jarg1;
59306   {
59307     try {
59308       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59309     } catch (std::out_of_range& e) {
59310       {
59311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59312       };
59313     } catch (std::exception& e) {
59314       {
59315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59316       };
59317     } catch (Dali::DaliException e) {
59318       {
59319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59320       };
59321     } catch (...) {
59322       {
59323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59324       };
59325     }
59326   }
59327
59328   jresult = (unsigned long)result;
59329   return jresult;
59330 }
59331
59332
59333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59334   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59335   bool (*arg2)() = (bool (*)()) 0 ;
59336
59337   arg1 = (Dali::Signal< bool () > *)jarg1;
59338   arg2 = (bool (*)())jarg2;
59339   {
59340     try {
59341       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59342     } catch (std::out_of_range& e) {
59343       {
59344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59345       };
59346     } catch (std::exception& e) {
59347       {
59348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59349       };
59350     } catch (Dali::DaliException e) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59353       };
59354     } catch (...) {
59355       {
59356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59357       };
59358     }
59359   }
59360
59361 }
59362
59363
59364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59365   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59366   bool (*arg2)() = (bool (*)()) 0 ;
59367
59368   arg1 = (Dali::Signal< bool () > *)jarg1;
59369   arg2 = (bool (*)())jarg2;
59370   {
59371     try {
59372       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59373     } catch (std::out_of_range& e) {
59374       {
59375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59376       };
59377     } catch (std::exception& e) {
59378       {
59379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59380       };
59381     } catch (Dali::DaliException e) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59384       };
59385     } catch (...) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59388       };
59389     }
59390   }
59391
59392 }
59393
59394
59395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59396   unsigned int jresult ;
59397   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59398   bool result;
59399
59400   arg1 = (Dali::Signal< bool () > *)jarg1;
59401   {
59402     try {
59403       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59404     } catch (std::out_of_range& e) {
59405       {
59406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59407       };
59408     } catch (std::exception& e) {
59409       {
59410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59411       };
59412     } catch (Dali::DaliException e) {
59413       {
59414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59415       };
59416     } catch (...) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59419       };
59420     }
59421   }
59422
59423   jresult = result;
59424   return jresult;
59425 }
59426
59427
59428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59429   void * jresult ;
59430   Dali::Signal< bool () > *result = 0 ;
59431
59432   {
59433     try {
59434       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59435     } catch (std::out_of_range& e) {
59436       {
59437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59438       };
59439     } catch (std::exception& e) {
59440       {
59441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (Dali::DaliException e) {
59444       {
59445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59450       };
59451     }
59452   }
59453
59454   jresult = (void *)result;
59455   return jresult;
59456 }
59457
59458
59459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59460   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59461
59462   arg1 = (Dali::Signal< bool () > *)jarg1;
59463   {
59464     try {
59465       delete arg1;
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59473       };
59474     } catch (Dali::DaliException e) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59477       };
59478     } catch (...) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59481       };
59482     }
59483   }
59484
59485 }
59486
59487
59488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59489   int jresult ;
59490   int result;
59491
59492   {
59493     try {
59494       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59495     } catch (std::out_of_range& e) {
59496       {
59497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59498       };
59499     } catch (std::exception& e) {
59500       {
59501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59502       };
59503     } catch (Dali::DaliException e) {
59504       {
59505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59506       };
59507     } catch (...) {
59508       {
59509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59510       };
59511     }
59512   }
59513
59514   jresult = (int)result;
59515   return jresult;
59516 }
59517
59518
59519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59520   int jresult ;
59521   int result;
59522
59523   {
59524     try {
59525       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59526     } catch (std::out_of_range& e) {
59527       {
59528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59529       };
59530     } catch (std::exception& e) {
59531       {
59532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59533       };
59534     } catch (Dali::DaliException e) {
59535       {
59536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59537       };
59538     } catch (...) {
59539       {
59540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59541       };
59542     }
59543   }
59544
59545   jresult = (int)result;
59546   return jresult;
59547 }
59548
59549
59550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59551   int jresult ;
59552   int result;
59553
59554   {
59555     try {
59556       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59557     } catch (std::out_of_range& e) {
59558       {
59559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59560       };
59561     } catch (std::exception& e) {
59562       {
59563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59564       };
59565     } catch (Dali::DaliException e) {
59566       {
59567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59568       };
59569     } catch (...) {
59570       {
59571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59572       };
59573     }
59574   }
59575
59576   jresult = (int)result;
59577   return jresult;
59578 }
59579
59580
59581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59582   int jresult ;
59583   int result;
59584
59585   {
59586     try {
59587       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59588     } catch (std::out_of_range& e) {
59589       {
59590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59591       };
59592     } catch (std::exception& e) {
59593       {
59594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59595       };
59596     } catch (Dali::DaliException e) {
59597       {
59598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59599       };
59600     } catch (...) {
59601       {
59602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59603       };
59604     }
59605   }
59606
59607   jresult = (int)result;
59608   return jresult;
59609 }
59610
59611
59612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59613   int jresult ;
59614   int result;
59615
59616   {
59617     try {
59618       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59619     } catch (std::out_of_range& e) {
59620       {
59621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59622       };
59623     } catch (std::exception& e) {
59624       {
59625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59626       };
59627     } catch (Dali::DaliException e) {
59628       {
59629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59630       };
59631     } catch (...) {
59632       {
59633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59634       };
59635     }
59636   }
59637
59638   jresult = (int)result;
59639   return jresult;
59640 }
59641
59642
59643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59644   int jresult ;
59645   int result;
59646
59647   {
59648     try {
59649       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59650     } catch (std::out_of_range& e) {
59651       {
59652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59653       };
59654     } catch (std::exception& e) {
59655       {
59656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59657       };
59658     } catch (Dali::DaliException e) {
59659       {
59660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59661       };
59662     } catch (...) {
59663       {
59664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59665       };
59666     }
59667   }
59668
59669   jresult = (int)result;
59670   return jresult;
59671 }
59672
59673
59674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59675   int jresult ;
59676   int result;
59677
59678   {
59679     try {
59680       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59681     } catch (std::out_of_range& e) {
59682       {
59683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (std::exception& e) {
59686       {
59687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59688       };
59689     } catch (Dali::DaliException e) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59692       };
59693     } catch (...) {
59694       {
59695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59696       };
59697     }
59698   }
59699
59700   jresult = (int)result;
59701   return jresult;
59702 }
59703
59704
59705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59706   int jresult ;
59707   int result;
59708
59709   {
59710     try {
59711       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59712     } catch (std::out_of_range& e) {
59713       {
59714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59715       };
59716     } catch (std::exception& e) {
59717       {
59718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (Dali::DaliException e) {
59721       {
59722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59723       };
59724     } catch (...) {
59725       {
59726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59727       };
59728     }
59729   }
59730
59731   jresult = (int)result;
59732   return jresult;
59733 }
59734
59735
59736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59737   int jresult ;
59738   int result;
59739
59740   {
59741     try {
59742       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (Dali::DaliException e) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59754       };
59755     } catch (...) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59758       };
59759     }
59760   }
59761
59762   jresult = (int)result;
59763   return jresult;
59764 }
59765
59766
59767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59768   int jresult ;
59769   int result;
59770
59771   {
59772     try {
59773       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59774     } catch (std::out_of_range& e) {
59775       {
59776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59777       };
59778     } catch (std::exception& e) {
59779       {
59780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59781       };
59782     } catch (Dali::DaliException e) {
59783       {
59784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59785       };
59786     } catch (...) {
59787       {
59788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59789       };
59790     }
59791   }
59792
59793   jresult = (int)result;
59794   return jresult;
59795 }
59796
59797
59798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59799   int jresult ;
59800   int result;
59801
59802   {
59803     try {
59804       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59805     } catch (std::out_of_range& e) {
59806       {
59807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59808       };
59809     } catch (std::exception& e) {
59810       {
59811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59812       };
59813     } catch (Dali::DaliException e) {
59814       {
59815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59816       };
59817     } catch (...) {
59818       {
59819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59820       };
59821     }
59822   }
59823
59824   jresult = (int)result;
59825   return jresult;
59826 }
59827
59828
59829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59830   int jresult ;
59831   int result;
59832
59833   {
59834     try {
59835       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59836     } catch (std::out_of_range& e) {
59837       {
59838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59839       };
59840     } catch (std::exception& e) {
59841       {
59842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59843       };
59844     } catch (Dali::DaliException e) {
59845       {
59846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59847       };
59848     } catch (...) {
59849       {
59850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59851       };
59852     }
59853   }
59854
59855   jresult = (int)result;
59856   return jresult;
59857 }
59858
59859
59860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59861   int jresult ;
59862   int result;
59863
59864   {
59865     try {
59866       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59867     } catch (std::out_of_range& e) {
59868       {
59869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59870       };
59871     } catch (std::exception& e) {
59872       {
59873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59874       };
59875     } catch (Dali::DaliException e) {
59876       {
59877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59878       };
59879     } catch (...) {
59880       {
59881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59882       };
59883     }
59884   }
59885
59886   jresult = (int)result;
59887   return jresult;
59888 }
59889
59890
59891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59892   int jresult ;
59893   int result;
59894
59895   {
59896     try {
59897       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59905       };
59906     } catch (Dali::DaliException e) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59909       };
59910     } catch (...) {
59911       {
59912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59913       };
59914     }
59915   }
59916
59917   jresult = (int)result;
59918   return jresult;
59919 }
59920
59921
59922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59923   int jresult ;
59924   int result;
59925
59926   {
59927     try {
59928       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59929     } catch (std::out_of_range& e) {
59930       {
59931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59932       };
59933     } catch (std::exception& e) {
59934       {
59935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59936       };
59937     } catch (Dali::DaliException e) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59940       };
59941     } catch (...) {
59942       {
59943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59944       };
59945     }
59946   }
59947
59948   jresult = (int)result;
59949   return jresult;
59950 }
59951
59952
59953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59954   int jresult ;
59955   int result;
59956
59957   {
59958     try {
59959       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59967       };
59968     } catch (Dali::DaliException e) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59971       };
59972     } catch (...) {
59973       {
59974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59975       };
59976     }
59977   }
59978
59979   jresult = (int)result;
59980   return jresult;
59981 }
59982
59983
59984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59985   int jresult ;
59986   int result;
59987
59988   {
59989     try {
59990       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59991     } catch (std::out_of_range& e) {
59992       {
59993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59994       };
59995     } catch (std::exception& e) {
59996       {
59997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59998       };
59999     } catch (Dali::DaliException e) {
60000       {
60001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60002       };
60003     } catch (...) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60006       };
60007     }
60008   }
60009
60010   jresult = (int)result;
60011   return jresult;
60012 }
60013
60014
60015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60016   int jresult ;
60017   int result;
60018
60019   {
60020     try {
60021       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60022     } catch (std::out_of_range& e) {
60023       {
60024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60025       };
60026     } catch (std::exception& e) {
60027       {
60028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60029       };
60030     } catch (Dali::DaliException e) {
60031       {
60032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60033       };
60034     } catch (...) {
60035       {
60036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60037       };
60038     }
60039   }
60040
60041   jresult = (int)result;
60042   return jresult;
60043 }
60044
60045
60046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60047   int jresult ;
60048   int result;
60049
60050   {
60051     try {
60052       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60053     } catch (std::out_of_range& e) {
60054       {
60055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60056       };
60057     } catch (std::exception& e) {
60058       {
60059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60060       };
60061     } catch (Dali::DaliException e) {
60062       {
60063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60064       };
60065     } catch (...) {
60066       {
60067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60068       };
60069     }
60070   }
60071
60072   jresult = (int)result;
60073   return jresult;
60074 }
60075
60076
60077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60078   int jresult ;
60079   int result;
60080
60081   {
60082     try {
60083       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60084     } catch (std::out_of_range& e) {
60085       {
60086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60087       };
60088     } catch (std::exception& e) {
60089       {
60090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60091       };
60092     } catch (Dali::DaliException e) {
60093       {
60094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60095       };
60096     } catch (...) {
60097       {
60098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60099       };
60100     }
60101   }
60102
60103   jresult = (int)result;
60104   return jresult;
60105 }
60106
60107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60108   int jresult ;
60109   int result;
60110
60111   {
60112     try {
60113       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60114     } catch (std::out_of_range& e) {
60115       {
60116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60117       };
60118     } catch (std::exception& e) {
60119       {
60120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60121       };
60122     } catch (Dali::DaliException e) {
60123       {
60124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60125       };
60126     } catch (...) {
60127       {
60128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60129       };
60130     }
60131   }
60132
60133   jresult = (int)result;
60134   return jresult;
60135 }
60136
60137
60138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60139   int jresult ;
60140   int result;
60141   {
60142     try
60143     {
60144       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60145     } catch (std::out_of_range& e) {
60146       {
60147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (std::exception& e) {
60150       {
60151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60152       };
60153     } catch (Dali::DaliException e) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60156       };
60157     } catch (...) {
60158       {
60159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60160       };
60161     }
60162   }
60163
60164   jresult = (int)result;
60165   return jresult;
60166 }
60167
60168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60169   int jresult ;
60170   int result;
60171   {
60172     try
60173     {
60174       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60175     } catch (std::out_of_range& e) {
60176       {
60177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60178       };
60179     } catch (std::exception& e) {
60180       {
60181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (Dali::DaliException e) {
60184       {
60185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60186       };
60187     } catch (...) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60190       };
60191     }
60192   }
60193
60194   jresult = (int)result;
60195   return jresult;
60196 }
60197
60198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60199   int jresult ;
60200   int result;
60201   {
60202     try
60203     {
60204       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60205     } catch (std::out_of_range& e) {
60206       {
60207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60208       };
60209     } catch (std::exception& e) {
60210       {
60211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60212       };
60213     } catch (Dali::DaliException e) {
60214       {
60215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60216       };
60217     } catch (...) {
60218       {
60219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60220       };
60221     }
60222   }
60223
60224   jresult = (int)result;
60225   return jresult;
60226 }
60227
60228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60229   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60230 }
60231
60232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60233   int jresult ;
60234   int result;
60235   {
60236     try
60237     {
60238       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60239     } catch (std::out_of_range& e) {
60240       {
60241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60242       };
60243     } catch (std::exception& e) {
60244       {
60245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60246       };
60247     } catch (Dali::DaliException e) {
60248       {
60249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60250       };
60251     } catch (...) {
60252       {
60253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60254       };
60255     }
60256   }
60257
60258   jresult = (int)result;
60259   return jresult;
60260 }
60261
60262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60263   int jresult ;
60264   int result;
60265   {
60266     try
60267     {
60268       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (Dali::DaliException e) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60280       };
60281     } catch (...) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60284       };
60285     }
60286   }
60287
60288   jresult = (int)result;
60289   return jresult;
60290 }
60291
60292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60293   int jresult ;
60294   int result;
60295
60296   {
60297     try {
60298       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60299     } catch (std::out_of_range& e) {
60300       {
60301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60302       };
60303     } catch (std::exception& e) {
60304       {
60305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (Dali::DaliException e) {
60308       {
60309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60310       };
60311     } catch (...) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60314       };
60315     }
60316   }
60317
60318   jresult = (int)result;
60319   return jresult;
60320 }
60321
60322
60323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60324   int jresult ;
60325   int result;
60326
60327   {
60328     try {
60329       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60330     } catch (std::out_of_range& e) {
60331       {
60332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60333       };
60334     } catch (std::exception& e) {
60335       {
60336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (Dali::DaliException e) {
60339       {
60340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60341       };
60342     } catch (...) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60345       };
60346     }
60347   }
60348
60349   jresult = (int)result;
60350   return jresult;
60351 }
60352
60353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60354   int jresult ;
60355   int result;
60356   {
60357     try
60358     {
60359       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60360     } catch (std::out_of_range& e) {
60361       {
60362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60363       };
60364     } catch (std::exception& e) {
60365       {
60366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60367       };
60368     } catch (...) {
60369       {
60370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60371       };
60372     }
60373   }
60374   jresult = (int)result;
60375   return jresult;
60376 }
60377
60378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60379   int jresult ;
60380   int result;
60381   {
60382     try
60383     {
60384       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60385     } catch (std::out_of_range& e) {
60386       {
60387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60388       };
60389     } catch (std::exception& e) {
60390       {
60391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60392       };
60393     } catch (...) {
60394       {
60395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60396       };
60397     }
60398   }
60399   jresult = (int)result;
60400   return jresult;
60401 }
60402
60403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60404   int jresult ;
60405   int result;
60406   {
60407     try
60408     {
60409       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60410     } catch (std::out_of_range& e) {
60411       {
60412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60413       };
60414     } catch (std::exception& e) {
60415       {
60416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60417       };
60418     } catch (...) {
60419       {
60420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60421       };
60422     }
60423   }
60424   jresult = (int)result;
60425   return jresult;
60426 }
60427
60428
60429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60430   int jresult ;
60431   int result;
60432   {
60433     try
60434     {
60435       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60436     } catch (std::out_of_range& e) {
60437       {
60438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60439       };
60440     } catch (std::exception& e) {
60441       {
60442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60443       };
60444     } catch (...) {
60445       {
60446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60447       };
60448     }
60449   }
60450   jresult = (int)result;
60451   return jresult;
60452 }
60453
60454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60455   int jresult ;
60456   int result;
60457   {
60458     try
60459     {
60460       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60461     } catch (std::out_of_range& e) {
60462       {
60463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60464       };
60465     } catch (std::exception& e) {
60466       {
60467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60468       };
60469     } catch (...) {
60470       {
60471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60472       };
60473     }
60474   }
60475   jresult = (int)result;
60476   return jresult;
60477 }
60478
60479
60480
60481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60482   int jresult ;
60483   int result;
60484
60485   {
60486     try {
60487       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60488     } catch (std::out_of_range& e) {
60489       {
60490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60491       };
60492     } catch (std::exception& e) {
60493       {
60494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60495       };
60496     } catch (Dali::DaliException e) {
60497       {
60498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60499       };
60500     } catch (...) {
60501       {
60502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60503       };
60504     }
60505   }
60506
60507   jresult = (int)result;
60508   return jresult;
60509 }
60510
60511
60512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60513   int jresult ;
60514   int result;
60515
60516   {
60517     try {
60518       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60519     } catch (std::out_of_range& e) {
60520       {
60521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60522       };
60523     } catch (std::exception& e) {
60524       {
60525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60526       };
60527     } catch (Dali::DaliException e) {
60528       {
60529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60530       };
60531     } catch (...) {
60532       {
60533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60534       };
60535     }
60536   }
60537
60538   jresult = (int)result;
60539   return jresult;
60540 }
60541
60542
60543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60544   int jresult ;
60545   int result;
60546
60547   {
60548     try {
60549       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60550     } catch (std::out_of_range& e) {
60551       {
60552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60553       };
60554     } catch (std::exception& e) {
60555       {
60556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60557       };
60558     } catch (Dali::DaliException e) {
60559       {
60560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60561       };
60562     } catch (...) {
60563       {
60564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60565       };
60566     }
60567   }
60568
60569   jresult = (int)result;
60570   return jresult;
60571 }
60572
60573
60574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60575   int jresult ;
60576   int result;
60577
60578   {
60579     try {
60580       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60581     } catch (std::out_of_range& e) {
60582       {
60583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60584       };
60585     } catch (std::exception& e) {
60586       {
60587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60588       };
60589     } catch (Dali::DaliException e) {
60590       {
60591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60592       };
60593     } catch (...) {
60594       {
60595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60596       };
60597     }
60598   }
60599
60600   jresult = (int)result;
60601   return jresult;
60602 }
60603
60604
60605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60606   int jresult ;
60607   int result;
60608
60609   {
60610     try {
60611       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60612     } catch (std::out_of_range& e) {
60613       {
60614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60615       };
60616     } catch (std::exception& e) {
60617       {
60618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60619       };
60620     } catch (Dali::DaliException e) {
60621       {
60622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60623       };
60624     } catch (...) {
60625       {
60626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60627       };
60628     }
60629   }
60630
60631   jresult = (int)result;
60632   return jresult;
60633 }
60634
60635
60636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60637   int jresult ;
60638   int result;
60639
60640   {
60641     try {
60642       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60643     } catch (std::out_of_range& e) {
60644       {
60645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60646       };
60647     } catch (std::exception& e) {
60648       {
60649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60650       };
60651     } catch (Dali::DaliException e) {
60652       {
60653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60654       };
60655     } catch (...) {
60656       {
60657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60658       };
60659     }
60660   }
60661
60662   jresult = (int)result;
60663   return jresult;
60664 }
60665
60666
60667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60668   int jresult ;
60669   int result;
60670
60671   {
60672     try {
60673       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60674     } catch (std::out_of_range& e) {
60675       {
60676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60677       };
60678     } catch (std::exception& e) {
60679       {
60680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60681       };
60682     } catch (Dali::DaliException e) {
60683       {
60684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60685       };
60686     } catch (...) {
60687       {
60688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60689       };
60690     }
60691   }
60692
60693   jresult = (int)result;
60694   return jresult;
60695 }
60696
60697 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60698   int jresult ;
60699   int result;
60700
60701   {
60702     try {
60703       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60704     } catch (std::out_of_range& e) {
60705       {
60706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60707       };
60708     } catch (std::exception& e) {
60709       {
60710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60711       };
60712     } catch (...) {
60713       {
60714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60715       };
60716     }
60717   }
60718   jresult = (int)result;
60719   return jresult;
60720 }
60721
60722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60723   int jresult ;
60724   int result;
60725
60726   {
60727     try {
60728       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60729     } catch (std::out_of_range& e) {
60730       {
60731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60732       };
60733     } catch (std::exception& e) {
60734       {
60735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60736       };
60737     } catch (Dali::DaliException e) {
60738       {
60739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60740       };
60741     } catch (...) {
60742       {
60743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60744       };
60745     }
60746   }
60747
60748   jresult = (int)result;
60749   return jresult;
60750 }
60751
60752
60753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60754   int jresult ;
60755   int result;
60756
60757   {
60758     try {
60759       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60760     } catch (std::out_of_range& e) {
60761       {
60762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60763       };
60764     } catch (std::exception& e) {
60765       {
60766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60767       };
60768     } catch (Dali::DaliException e) {
60769       {
60770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60771       };
60772     } catch (...) {
60773       {
60774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60775       };
60776     }
60777   }
60778
60779   jresult = (int)result;
60780   return jresult;
60781 }
60782
60783
60784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60785   int jresult ;
60786   int result;
60787
60788   {
60789     try {
60790       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60791     } catch (std::out_of_range& e) {
60792       {
60793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60794       };
60795     } catch (std::exception& e) {
60796       {
60797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60798       };
60799     } catch (Dali::DaliException e) {
60800       {
60801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60802       };
60803     } catch (...) {
60804       {
60805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60806       };
60807     }
60808   }
60809
60810   jresult = (int)result;
60811   return jresult;
60812 }
60813
60814
60815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60816   int jresult ;
60817   int result;
60818
60819   {
60820     try {
60821       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60822     } catch (std::out_of_range& e) {
60823       {
60824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60825       };
60826     } catch (std::exception& e) {
60827       {
60828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60829       };
60830     } catch (Dali::DaliException e) {
60831       {
60832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60833       };
60834     } catch (...) {
60835       {
60836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60837       };
60838     }
60839   }
60840
60841   jresult = (int)result;
60842   return jresult;
60843 }
60844
60845
60846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60847   int jresult ;
60848   int result;
60849
60850   {
60851     try {
60852       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60853     } catch (std::out_of_range& e) {
60854       {
60855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60856       };
60857     } catch (std::exception& e) {
60858       {
60859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (Dali::DaliException e) {
60862       {
60863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60864       };
60865     } catch (...) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60868       };
60869     }
60870   }
60871
60872   jresult = (int)result;
60873   return jresult;
60874 }
60875
60876
60877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60878   int jresult ;
60879   int result;
60880
60881   {
60882     try {
60883       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60884     } catch (std::out_of_range& e) {
60885       {
60886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60887       };
60888     } catch (std::exception& e) {
60889       {
60890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (Dali::DaliException e) {
60893       {
60894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60899       };
60900     }
60901   }
60902
60903   jresult = (int)result;
60904   return jresult;
60905 }
60906
60907
60908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60909   int jresult ;
60910   int result;
60911
60912   {
60913     try {
60914       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60915     } catch (std::out_of_range& e) {
60916       {
60917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60918       };
60919     } catch (std::exception& e) {
60920       {
60921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60922       };
60923     } catch (Dali::DaliException e) {
60924       {
60925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60926       };
60927     } catch (...) {
60928       {
60929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60930       };
60931     }
60932   }
60933
60934   jresult = (int)result;
60935   return jresult;
60936 }
60937
60938
60939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60940   int jresult ;
60941   int result;
60942
60943   {
60944     try {
60945       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60946     } catch (std::out_of_range& e) {
60947       {
60948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60949       };
60950     } catch (std::exception& e) {
60951       {
60952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60953       };
60954     } catch (Dali::DaliException e) {
60955       {
60956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60957       };
60958     } catch (...) {
60959       {
60960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60961       };
60962     }
60963   }
60964
60965   jresult = (int)result;
60966   return jresult;
60967 }
60968
60969
60970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60971   int jresult ;
60972   int result;
60973
60974   {
60975     try {
60976       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60977     } catch (std::out_of_range& e) {
60978       {
60979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60980       };
60981     } catch (std::exception& e) {
60982       {
60983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60984       };
60985     } catch (Dali::DaliException e) {
60986       {
60987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60988       };
60989     } catch (...) {
60990       {
60991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60992       };
60993     }
60994   }
60995
60996   jresult = (int)result;
60997   return jresult;
60998 }
60999
61000
61001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
61002   int jresult ;
61003   int result;
61004
61005   {
61006     try {
61007       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61008     } catch (std::out_of_range& e) {
61009       {
61010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61011       };
61012     } catch (std::exception& e) {
61013       {
61014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61015       };
61016     } catch (Dali::DaliException e) {
61017       {
61018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61019       };
61020     } catch (...) {
61021       {
61022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61023       };
61024     }
61025   }
61026
61027   jresult = (int)result;
61028   return jresult;
61029 }
61030
61031
61032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61033   int jresult ;
61034   int result;
61035
61036   {
61037     try {
61038       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61039     } catch (std::out_of_range& e) {
61040       {
61041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61042       };
61043     } catch (std::exception& e) {
61044       {
61045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61046       };
61047     } catch (Dali::DaliException e) {
61048       {
61049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61050       };
61051     } catch (...) {
61052       {
61053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61054       };
61055     }
61056   }
61057
61058   jresult = (int)result;
61059   return jresult;
61060 }
61061
61062
61063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61064   int jresult ;
61065   int result;
61066
61067   {
61068     try {
61069       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61070     } catch (std::out_of_range& e) {
61071       {
61072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61073       };
61074     } catch (std::exception& e) {
61075       {
61076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61077       };
61078     } catch (Dali::DaliException e) {
61079       {
61080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61081       };
61082     } catch (...) {
61083       {
61084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61085       };
61086     }
61087   }
61088
61089   jresult = (int)result;
61090   return jresult;
61091 }
61092
61093
61094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61095   int jresult ;
61096   int result;
61097
61098   {
61099     try {
61100       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61101     } catch (std::out_of_range& e) {
61102       {
61103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61104       };
61105     } catch (std::exception& e) {
61106       {
61107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61108       };
61109     } catch (Dali::DaliException e) {
61110       {
61111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61112       };
61113     } catch (...) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61116       };
61117     }
61118   }
61119
61120   jresult = (int)result;
61121   return jresult;
61122 }
61123
61124
61125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61126   int jresult ;
61127   int result;
61128
61129   {
61130     try {
61131       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61132     } catch (std::out_of_range& e) {
61133       {
61134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61135       };
61136     } catch (std::exception& e) {
61137       {
61138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61139       };
61140     } catch (Dali::DaliException e) {
61141       {
61142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61143       };
61144     } catch (...) {
61145       {
61146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61147       };
61148     }
61149   }
61150
61151   jresult = (int)result;
61152   return jresult;
61153 }
61154
61155
61156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61157   int jresult ;
61158   int result;
61159
61160   {
61161     try {
61162       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61163     } catch (std::out_of_range& e) {
61164       {
61165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61166       };
61167     } catch (std::exception& e) {
61168       {
61169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61170       };
61171     } catch (Dali::DaliException e) {
61172       {
61173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61174       };
61175     } catch (...) {
61176       {
61177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61178       };
61179     }
61180   }
61181
61182   jresult = (int)result;
61183   return jresult;
61184 }
61185
61186
61187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61188   int jresult ;
61189   int result;
61190
61191   {
61192     try {
61193       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61194     } catch (std::out_of_range& e) {
61195       {
61196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61197       };
61198     } catch (std::exception& e) {
61199       {
61200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61201       };
61202     } catch (Dali::DaliException e) {
61203       {
61204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61205       };
61206     } catch (...) {
61207       {
61208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61209       };
61210     }
61211   }
61212
61213   jresult = (int)result;
61214   return jresult;
61215 }
61216
61217
61218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61219   int jresult ;
61220   int result;
61221
61222   {
61223     try {
61224       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61225     } catch (std::out_of_range& e) {
61226       {
61227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61228       };
61229     } catch (std::exception& e) {
61230       {
61231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61232       };
61233     } catch (Dali::DaliException e) {
61234       {
61235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61236       };
61237     } catch (...) {
61238       {
61239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61240       };
61241     }
61242   }
61243
61244   jresult = (int)result;
61245   return jresult;
61246 }
61247
61248
61249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61250   int jresult ;
61251   int result;
61252
61253   {
61254     try {
61255       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61256     } catch (std::out_of_range& e) {
61257       {
61258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61259       };
61260     } catch (std::exception& e) {
61261       {
61262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61263       };
61264     } catch (Dali::DaliException e) {
61265       {
61266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61267       };
61268     } catch (...) {
61269       {
61270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61271       };
61272     }
61273   }
61274
61275   jresult = (int)result;
61276   return jresult;
61277 }
61278
61279
61280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61281   int jresult ;
61282   int result;
61283
61284   {
61285     try {
61286       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61287     } catch (std::out_of_range& e) {
61288       {
61289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61290       };
61291     } catch (std::exception& e) {
61292       {
61293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61294       };
61295     } catch (Dali::DaliException e) {
61296       {
61297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61298       };
61299     } catch (...) {
61300       {
61301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61302       };
61303     }
61304   }
61305
61306   jresult = (int)result;
61307   return jresult;
61308 }
61309
61310
61311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61312   int jresult ;
61313   int result;
61314
61315   {
61316     try {
61317       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61318     } catch (std::out_of_range& e) {
61319       {
61320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (std::exception& e) {
61323       {
61324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61325       };
61326     } catch (Dali::DaliException e) {
61327       {
61328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61329       };
61330     } catch (...) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61333       };
61334     }
61335   }
61336
61337   jresult = (int)result;
61338   return jresult;
61339 }
61340
61341
61342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61343   int jresult ;
61344   int result;
61345
61346   {
61347     try {
61348       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61349     } catch (std::out_of_range& e) {
61350       {
61351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61352       };
61353     } catch (std::exception& e) {
61354       {
61355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61356       };
61357     } catch (Dali::DaliException e) {
61358       {
61359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61360       };
61361     } catch (...) {
61362       {
61363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61364       };
61365     }
61366   }
61367
61368   jresult = (int)result;
61369   return jresult;
61370 }
61371
61372
61373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61374   int jresult ;
61375   int result;
61376
61377   {
61378     try {
61379       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61380     } catch (std::out_of_range& e) {
61381       {
61382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61383       };
61384     } catch (std::exception& e) {
61385       {
61386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61387       };
61388     } catch (Dali::DaliException e) {
61389       {
61390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61391       };
61392     } catch (...) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61395       };
61396     }
61397   }
61398
61399   jresult = (int)result;
61400   return jresult;
61401 }
61402
61403
61404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61405   int jresult ;
61406   int result;
61407
61408   {
61409     try {
61410       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61411     } catch (std::out_of_range& e) {
61412       {
61413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61414       };
61415     } catch (std::exception& e) {
61416       {
61417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61418       };
61419     } catch (Dali::DaliException e) {
61420       {
61421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61422       };
61423     } catch (...) {
61424       {
61425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61426       };
61427     }
61428   }
61429
61430   jresult = (int)result;
61431   return jresult;
61432 }
61433
61434
61435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61436   int jresult ;
61437   int result;
61438
61439   {
61440     try {
61441       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61442     } catch (std::out_of_range& e) {
61443       {
61444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61445       };
61446     } catch (std::exception& e) {
61447       {
61448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61449       };
61450     } catch (Dali::DaliException e) {
61451       {
61452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61453       };
61454     } catch (...) {
61455       {
61456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61457       };
61458     }
61459   }
61460
61461   jresult = (int)result;
61462   return jresult;
61463 }
61464
61465
61466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61467   int jresult ;
61468   int result;
61469
61470   {
61471     try {
61472       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61473     } catch (std::out_of_range& e) {
61474       {
61475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61476       };
61477     } catch (std::exception& e) {
61478       {
61479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61480       };
61481     } catch (Dali::DaliException e) {
61482       {
61483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61484       };
61485     } catch (...) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61488       };
61489     }
61490   }
61491
61492   jresult = (int)result;
61493   return jresult;
61494 }
61495
61496
61497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61498   int jresult ;
61499   int result;
61500
61501   {
61502     try {
61503       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61504     } catch (std::out_of_range& e) {
61505       {
61506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61507       };
61508     } catch (std::exception& e) {
61509       {
61510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61511       };
61512     } catch (Dali::DaliException e) {
61513       {
61514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61515       };
61516     } catch (...) {
61517       {
61518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61519       };
61520     }
61521   }
61522
61523   jresult = (int)result;
61524   return jresult;
61525 }
61526
61527
61528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61529   int jresult ;
61530   int result;
61531
61532   {
61533     try {
61534       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61535     } catch (std::out_of_range& e) {
61536       {
61537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61538       };
61539     } catch (std::exception& e) {
61540       {
61541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61542       };
61543     } catch (Dali::DaliException e) {
61544       {
61545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61546       };
61547     } catch (...) {
61548       {
61549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61550       };
61551     }
61552   }
61553
61554   jresult = (int)result;
61555   return jresult;
61556 }
61557
61558
61559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61560   int jresult ;
61561   int result;
61562
61563   {
61564     try {
61565       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61566     } catch (std::out_of_range& e) {
61567       {
61568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61569       };
61570     } catch (std::exception& e) {
61571       {
61572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61573       };
61574     } catch (Dali::DaliException e) {
61575       {
61576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61577       };
61578     } catch (...) {
61579       {
61580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61581       };
61582     }
61583   }
61584
61585   jresult = (int)result;
61586   return jresult;
61587 }
61588
61589
61590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61591   void * jresult ;
61592   Dali::Toolkit::Builder *result = 0 ;
61593
61594   {
61595     try {
61596       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61597     } catch (std::out_of_range& e) {
61598       {
61599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61600       };
61601     } catch (std::exception& e) {
61602       {
61603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61604       };
61605     } catch (Dali::DaliException e) {
61606       {
61607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61608       };
61609     } catch (...) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61612       };
61613     }
61614   }
61615
61616   jresult = (void *)result;
61617   return jresult;
61618 }
61619
61620
61621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61622   void * jresult ;
61623   Dali::Toolkit::Builder result;
61624
61625   {
61626     try {
61627       result = Dali::Toolkit::Builder::New();
61628     } catch (std::out_of_range& e) {
61629       {
61630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61631       };
61632     } catch (std::exception& e) {
61633       {
61634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61635       };
61636     } catch (Dali::DaliException e) {
61637       {
61638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61639       };
61640     } catch (...) {
61641       {
61642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61643       };
61644     }
61645   }
61646
61647   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61648   return jresult;
61649 }
61650
61651
61652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61653   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61654
61655   arg1 = (Dali::Toolkit::Builder *)jarg1;
61656   {
61657     try {
61658       delete arg1;
61659     } catch (std::out_of_range& e) {
61660       {
61661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61662       };
61663     } catch (std::exception& e) {
61664       {
61665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61666       };
61667     } catch (Dali::DaliException e) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61670       };
61671     } catch (...) {
61672       {
61673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61674       };
61675     }
61676   }
61677
61678 }
61679
61680
61681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61682   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61683   std::string *arg2 = 0 ;
61684   Dali::Toolkit::Builder::UIFormat arg3 ;
61685
61686   arg1 = (Dali::Toolkit::Builder *)jarg1;
61687   if (!jarg2) {
61688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61689     return ;
61690   }
61691   std::string arg2_str(jarg2);
61692   arg2 = &arg2_str;
61693   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61694   {
61695     try {
61696       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61697     } catch (std::out_of_range& e) {
61698       {
61699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61700       };
61701     } catch (std::exception& e) {
61702       {
61703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61704       };
61705     } catch (Dali::DaliException e) {
61706       {
61707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61708       };
61709     } catch (...) {
61710       {
61711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61712       };
61713     }
61714   }
61715
61716
61717   //argout typemap for const std::string&
61718
61719 }
61720
61721
61722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61723   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61724   std::string *arg2 = 0 ;
61725
61726   arg1 = (Dali::Toolkit::Builder *)jarg1;
61727   if (!jarg2) {
61728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61729     return ;
61730   }
61731   std::string arg2_str(jarg2);
61732   arg2 = &arg2_str;
61733   {
61734     try {
61735       (arg1)->LoadFromString((std::string const &)*arg2);
61736     } catch (std::out_of_range& e) {
61737       {
61738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61739       };
61740     } catch (std::exception& e) {
61741       {
61742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61743       };
61744     } catch (Dali::DaliException e) {
61745       {
61746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61747       };
61748     } catch (...) {
61749       {
61750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61751       };
61752     }
61753   }
61754
61755
61756   //argout typemap for const std::string&
61757
61758 }
61759
61760
61761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61762   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61763   Dali::Property::Map *arg2 = 0 ;
61764
61765   arg1 = (Dali::Toolkit::Builder *)jarg1;
61766   arg2 = (Dali::Property::Map *)jarg2;
61767   if (!arg2) {
61768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61769     return ;
61770   }
61771   {
61772     try {
61773       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61774     } catch (std::out_of_range& e) {
61775       {
61776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61777       };
61778     } catch (std::exception& e) {
61779       {
61780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61781       };
61782     } catch (Dali::DaliException e) {
61783       {
61784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61785       };
61786     } catch (...) {
61787       {
61788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61789       };
61790     }
61791   }
61792
61793 }
61794
61795
61796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61797   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61798   std::string *arg2 = 0 ;
61799   Dali::Property::Value *arg3 = 0 ;
61800
61801   arg1 = (Dali::Toolkit::Builder *)jarg1;
61802   if (!jarg2) {
61803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61804     return ;
61805   }
61806   std::string arg2_str(jarg2);
61807   arg2 = &arg2_str;
61808   arg3 = (Dali::Property::Value *)jarg3;
61809   if (!arg3) {
61810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61811     return ;
61812   }
61813   {
61814     try {
61815       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61816     } catch (std::out_of_range& e) {
61817       {
61818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61819       };
61820     } catch (std::exception& e) {
61821       {
61822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61823       };
61824     } catch (Dali::DaliException e) {
61825       {
61826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61827       };
61828     } catch (...) {
61829       {
61830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61831       };
61832     }
61833   }
61834
61835
61836   //argout typemap for const std::string&
61837
61838 }
61839
61840
61841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61842   void * jresult ;
61843   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61844   Dali::Property::Map *result = 0 ;
61845
61846   arg1 = (Dali::Toolkit::Builder *)jarg1;
61847   {
61848     try {
61849       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61850     } catch (std::out_of_range& e) {
61851       {
61852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61853       };
61854     } catch (std::exception& e) {
61855       {
61856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61857       };
61858     } catch (Dali::DaliException e) {
61859       {
61860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61861       };
61862     } catch (...) {
61863       {
61864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61865       };
61866     }
61867   }
61868
61869   jresult = (void *)result;
61870   return jresult;
61871 }
61872
61873
61874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61875   void * jresult ;
61876   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61877   std::string *arg2 = 0 ;
61878   Dali::Property::Value *result = 0 ;
61879
61880   arg1 = (Dali::Toolkit::Builder *)jarg1;
61881   if (!jarg2) {
61882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61883     return 0;
61884   }
61885   std::string arg2_str(jarg2);
61886   arg2 = &arg2_str;
61887   {
61888     try {
61889       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61890     } catch (std::out_of_range& e) {
61891       {
61892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61893       };
61894     } catch (std::exception& e) {
61895       {
61896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (Dali::DaliException e) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61901       };
61902     } catch (...) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61905       };
61906     }
61907   }
61908
61909   jresult = (void *)result;
61910
61911   //argout typemap for const std::string&
61912
61913   return jresult;
61914 }
61915
61916
61917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61918   void * jresult ;
61919   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61920   std::string *arg2 = 0 ;
61921   Dali::Animation result;
61922
61923   arg1 = (Dali::Toolkit::Builder *)jarg1;
61924   if (!jarg2) {
61925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61926     return 0;
61927   }
61928   std::string arg2_str(jarg2);
61929   arg2 = &arg2_str;
61930   {
61931     try {
61932       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61933     } catch (std::out_of_range& e) {
61934       {
61935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61936       };
61937     } catch (std::exception& e) {
61938       {
61939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61940       };
61941     } catch (Dali::DaliException e) {
61942       {
61943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61944       };
61945     } catch (...) {
61946       {
61947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61948       };
61949     }
61950   }
61951
61952   jresult = new Dali::Animation((const Dali::Animation &)result);
61953
61954   //argout typemap for const std::string&
61955
61956   return jresult;
61957 }
61958
61959
61960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61961   void * jresult ;
61962   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61963   std::string *arg2 = 0 ;
61964   Dali::Property::Map *arg3 = 0 ;
61965   Dali::Animation result;
61966
61967   arg1 = (Dali::Toolkit::Builder *)jarg1;
61968   if (!jarg2) {
61969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61970     return 0;
61971   }
61972   std::string arg2_str(jarg2);
61973   arg2 = &arg2_str;
61974   arg3 = (Dali::Property::Map *)jarg3;
61975   if (!arg3) {
61976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61977     return 0;
61978   }
61979   {
61980     try {
61981       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61982     } catch (std::out_of_range& e) {
61983       {
61984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61985       };
61986     } catch (std::exception& e) {
61987       {
61988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61989       };
61990     } catch (Dali::DaliException e) {
61991       {
61992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61993       };
61994     } catch (...) {
61995       {
61996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61997       };
61998     }
61999   }
62000
62001   jresult = new Dali::Animation((const Dali::Animation &)result);
62002
62003   //argout typemap for const std::string&
62004
62005   return jresult;
62006 }
62007
62008
62009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62010   void * jresult ;
62011   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62012   std::string *arg2 = 0 ;
62013   Dali::Actor arg3 ;
62014   Dali::Actor *argp3 ;
62015   Dali::Animation result;
62016
62017   arg1 = (Dali::Toolkit::Builder *)jarg1;
62018   if (!jarg2) {
62019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62020     return 0;
62021   }
62022   std::string arg2_str(jarg2);
62023   arg2 = &arg2_str;
62024   argp3 = (Dali::Actor *)jarg3;
62025   if (!argp3) {
62026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62027     return 0;
62028   }
62029   arg3 = *argp3;
62030   {
62031     try {
62032       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62033     } catch (std::out_of_range& e) {
62034       {
62035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62036       };
62037     } catch (std::exception& e) {
62038       {
62039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62040       };
62041     } catch (Dali::DaliException e) {
62042       {
62043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62044       };
62045     } catch (...) {
62046       {
62047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62048       };
62049     }
62050   }
62051
62052   jresult = new Dali::Animation((const Dali::Animation &)result);
62053
62054   //argout typemap for const std::string&
62055
62056   return jresult;
62057 }
62058
62059
62060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62061   void * jresult ;
62062   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62063   std::string *arg2 = 0 ;
62064   Dali::Property::Map *arg3 = 0 ;
62065   Dali::Actor arg4 ;
62066   Dali::Actor *argp4 ;
62067   Dali::Animation result;
62068
62069   arg1 = (Dali::Toolkit::Builder *)jarg1;
62070   if (!jarg2) {
62071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62072     return 0;
62073   }
62074   std::string arg2_str(jarg2);
62075   arg2 = &arg2_str;
62076   arg3 = (Dali::Property::Map *)jarg3;
62077   if (!arg3) {
62078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62079     return 0;
62080   }
62081   argp4 = (Dali::Actor *)jarg4;
62082   if (!argp4) {
62083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62084     return 0;
62085   }
62086   arg4 = *argp4;
62087   {
62088     try {
62089       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62090     } catch (std::out_of_range& e) {
62091       {
62092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62093       };
62094     } catch (std::exception& e) {
62095       {
62096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62097       };
62098     } catch (Dali::DaliException e) {
62099       {
62100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62101       };
62102     } catch (...) {
62103       {
62104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62105       };
62106     }
62107   }
62108
62109   jresult = new Dali::Animation((const Dali::Animation &)result);
62110
62111   //argout typemap for const std::string&
62112
62113   return jresult;
62114 }
62115
62116
62117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62118   void * jresult ;
62119   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62120   std::string *arg2 = 0 ;
62121   Dali::BaseHandle result;
62122
62123   arg1 = (Dali::Toolkit::Builder *)jarg1;
62124   if (!jarg2) {
62125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62126     return 0;
62127   }
62128   std::string arg2_str(jarg2);
62129   arg2 = &arg2_str;
62130   {
62131     try {
62132       result = (arg1)->Create((std::string const &)*arg2);
62133     } catch (std::out_of_range& e) {
62134       {
62135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62136       };
62137     } catch (std::exception& e) {
62138       {
62139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62140       };
62141     } catch (Dali::DaliException e) {
62142       {
62143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62144       };
62145     } catch (...) {
62146       {
62147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62148       };
62149     }
62150   }
62151
62152   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62153
62154   //argout typemap for const std::string&
62155
62156   return jresult;
62157 }
62158
62159
62160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62161   void * jresult ;
62162   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62163   std::string *arg2 = 0 ;
62164   Dali::Property::Map *arg3 = 0 ;
62165   Dali::BaseHandle result;
62166
62167   arg1 = (Dali::Toolkit::Builder *)jarg1;
62168   if (!jarg2) {
62169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62170     return 0;
62171   }
62172   std::string arg2_str(jarg2);
62173   arg2 = &arg2_str;
62174   arg3 = (Dali::Property::Map *)jarg3;
62175   if (!arg3) {
62176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62177     return 0;
62178   }
62179   {
62180     try {
62181       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62182     } catch (std::out_of_range& e) {
62183       {
62184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62185       };
62186     } catch (std::exception& e) {
62187       {
62188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62189       };
62190     } catch (Dali::DaliException e) {
62191       {
62192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62193       };
62194     } catch (...) {
62195       {
62196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62197       };
62198     }
62199   }
62200
62201   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62202
62203   //argout typemap for const std::string&
62204
62205   return jresult;
62206 }
62207
62208
62209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62210   void * jresult ;
62211   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62212   std::string *arg2 = 0 ;
62213   Dali::BaseHandle result;
62214
62215   arg1 = (Dali::Toolkit::Builder *)jarg1;
62216   if (!jarg2) {
62217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62218     return 0;
62219   }
62220   std::string arg2_str(jarg2);
62221   arg2 = &arg2_str;
62222   {
62223     try {
62224       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62225     } catch (std::out_of_range& e) {
62226       {
62227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62228       };
62229     } catch (std::exception& e) {
62230       {
62231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62232       };
62233     } catch (Dali::DaliException e) {
62234       {
62235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62236       };
62237     } catch (...) {
62238       {
62239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62240       };
62241     }
62242   }
62243
62244   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62245
62246   //argout typemap for const std::string&
62247
62248   return jresult;
62249 }
62250
62251
62252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62253   unsigned int jresult ;
62254   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62255   std::string *arg2 = 0 ;
62256   Dali::Handle *arg3 = 0 ;
62257   bool result;
62258
62259   arg1 = (Dali::Toolkit::Builder *)jarg1;
62260   if (!jarg2) {
62261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62262     return 0;
62263   }
62264   std::string arg2_str(jarg2);
62265   arg2 = &arg2_str;
62266   arg3 = (Dali::Handle *)jarg3;
62267   if (!arg3) {
62268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62269     return 0;
62270   }
62271   {
62272     try {
62273       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62274     } catch (std::out_of_range& e) {
62275       {
62276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62277       };
62278     } catch (std::exception& e) {
62279       {
62280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62281       };
62282     } catch (Dali::DaliException e) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62285       };
62286     } catch (...) {
62287       {
62288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62289       };
62290     }
62291   }
62292
62293   jresult = result;
62294
62295   //argout typemap for const std::string&
62296
62297   return jresult;
62298 }
62299
62300
62301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62302   unsigned int jresult ;
62303   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62304   Dali::Handle *arg2 = 0 ;
62305   std::string *arg3 = 0 ;
62306   bool result;
62307
62308   arg1 = (Dali::Toolkit::Builder *)jarg1;
62309   arg2 = (Dali::Handle *)jarg2;
62310   if (!arg2) {
62311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62312     return 0;
62313   }
62314   if (!jarg3) {
62315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62316     return 0;
62317   }
62318   std::string arg3_str(jarg3);
62319   arg3 = &arg3_str;
62320   {
62321     try {
62322       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62323     } catch (std::out_of_range& e) {
62324       {
62325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62326       };
62327     } catch (std::exception& e) {
62328       {
62329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62330       };
62331     } catch (Dali::DaliException e) {
62332       {
62333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62334       };
62335     } catch (...) {
62336       {
62337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62338       };
62339     }
62340   }
62341
62342   jresult = result;
62343
62344   //argout typemap for const std::string&
62345
62346   return jresult;
62347 }
62348
62349
62350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62351   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62352   Dali::Actor arg2 ;
62353   Dali::Actor *argp2 ;
62354
62355   arg1 = (Dali::Toolkit::Builder *)jarg1;
62356   argp2 = (Dali::Actor *)jarg2;
62357   if (!argp2) {
62358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62359     return ;
62360   }
62361   arg2 = *argp2;
62362   {
62363     try {
62364       (arg1)->AddActors(arg2);
62365     } catch (std::out_of_range& e) {
62366       {
62367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62368       };
62369     } catch (std::exception& e) {
62370       {
62371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62372       };
62373     } catch (Dali::DaliException e) {
62374       {
62375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62376       };
62377     } catch (...) {
62378       {
62379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62380       };
62381     }
62382   }
62383
62384 }
62385
62386
62387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62388   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62389   std::string *arg2 = 0 ;
62390   Dali::Actor arg3 ;
62391   Dali::Actor *argp3 ;
62392
62393   arg1 = (Dali::Toolkit::Builder *)jarg1;
62394   if (!jarg2) {
62395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62396     return ;
62397   }
62398   std::string arg2_str(jarg2);
62399   arg2 = &arg2_str;
62400   argp3 = (Dali::Actor *)jarg3;
62401   if (!argp3) {
62402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62403     return ;
62404   }
62405   arg3 = *argp3;
62406   {
62407     try {
62408       (arg1)->AddActors((std::string const &)*arg2,arg3);
62409     } catch (std::out_of_range& e) {
62410       {
62411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62412       };
62413     } catch (std::exception& e) {
62414       {
62415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62416       };
62417     } catch (Dali::DaliException e) {
62418       {
62419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62420       };
62421     } catch (...) {
62422       {
62423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62424       };
62425     }
62426   }
62427
62428
62429   //argout typemap for const std::string&
62430
62431 }
62432
62433
62434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62435   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62436   std::string *arg2 = 0 ;
62437
62438   arg1 = (Dali::Toolkit::Builder *)jarg1;
62439   if (!jarg2) {
62440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62441     return ;
62442   }
62443   std::string arg2_str(jarg2);
62444   arg2 = &arg2_str;
62445   {
62446     try {
62447       (arg1)->CreateRenderTask((std::string const &)*arg2);
62448     } catch (std::out_of_range& e) {
62449       {
62450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62451       };
62452     } catch (std::exception& e) {
62453       {
62454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62455       };
62456     } catch (Dali::DaliException e) {
62457       {
62458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62459       };
62460     } catch (...) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62463       };
62464     }
62465   }
62466
62467
62468   //argout typemap for const std::string&
62469
62470 }
62471
62472
62473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62474   void * jresult ;
62475   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62476   std::string *arg2 = 0 ;
62477   Dali::FrameBufferImage result;
62478
62479   arg1 = (Dali::Toolkit::Builder *)jarg1;
62480   if (!jarg2) {
62481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62482     return 0;
62483   }
62484   std::string arg2_str(jarg2);
62485   arg2 = &arg2_str;
62486   {
62487     try {
62488       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62489     } catch (std::out_of_range& e) {
62490       {
62491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62492       };
62493     } catch (std::exception& e) {
62494       {
62495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62496       };
62497     } catch (Dali::DaliException e) {
62498       {
62499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62500       };
62501     } catch (...) {
62502       {
62503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62504       };
62505     }
62506   }
62507
62508   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62509
62510   //argout typemap for const std::string&
62511
62512   return jresult;
62513 }
62514
62515
62516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62517   void * jresult ;
62518   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62519   std::string *arg2 = 0 ;
62520   Dali::Path result;
62521
62522   arg1 = (Dali::Toolkit::Builder *)jarg1;
62523   if (!jarg2) {
62524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62525     return 0;
62526   }
62527   std::string arg2_str(jarg2);
62528   arg2 = &arg2_str;
62529   {
62530     try {
62531       result = (arg1)->GetPath((std::string const &)*arg2);
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (Dali::DaliException e) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550
62551   jresult = new Dali::Path((const Dali::Path &)result);
62552
62553   //argout typemap for const std::string&
62554
62555   return jresult;
62556 }
62557
62558
62559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62560   void * jresult ;
62561   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62562   std::string *arg2 = 0 ;
62563   Dali::PathConstrainer result;
62564
62565   arg1 = (Dali::Toolkit::Builder *)jarg1;
62566   if (!jarg2) {
62567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62568     return 0;
62569   }
62570   std::string arg2_str(jarg2);
62571   arg2 = &arg2_str;
62572   {
62573     try {
62574       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62575     } catch (std::out_of_range& e) {
62576       {
62577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62578       };
62579     } catch (std::exception& e) {
62580       {
62581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62582       };
62583     } catch (Dali::DaliException e) {
62584       {
62585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62586       };
62587     } catch (...) {
62588       {
62589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62590       };
62591     }
62592   }
62593
62594   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62595
62596   //argout typemap for const std::string&
62597
62598   return jresult;
62599 }
62600
62601
62602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62603   void * jresult ;
62604   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62605   std::string *arg2 = 0 ;
62606   Dali::LinearConstrainer result;
62607
62608   arg1 = (Dali::Toolkit::Builder *)jarg1;
62609   if (!jarg2) {
62610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62611     return 0;
62612   }
62613   std::string arg2_str(jarg2);
62614   arg2 = &arg2_str;
62615   {
62616     try {
62617       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62618     } catch (std::out_of_range& e) {
62619       {
62620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62621       };
62622     } catch (std::exception& e) {
62623       {
62624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62625       };
62626     } catch (Dali::DaliException e) {
62627       {
62628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62629       };
62630     } catch (...) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62633       };
62634     }
62635   }
62636
62637   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62638
62639   //argout typemap for const std::string&
62640
62641   return jresult;
62642 }
62643
62644
62645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62646   void * jresult ;
62647   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62648   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62649
62650   arg1 = (Dali::Toolkit::Builder *)jarg1;
62651   {
62652     try {
62653       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62654     } catch (std::out_of_range& e) {
62655       {
62656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (std::exception& e) {
62659       {
62660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62661       };
62662     } catch (Dali::DaliException e) {
62663       {
62664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62665       };
62666     } catch (...) {
62667       {
62668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62669       };
62670     }
62671   }
62672
62673   jresult = (void *)result;
62674   return jresult;
62675 }
62676
62677
62678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62679   void * jresult ;
62680   Dali::Toolkit::TransitionData *result = 0 ;
62681
62682   {
62683     try {
62684       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62685     } catch (std::out_of_range& e) {
62686       {
62687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (std::exception& e) {
62690       {
62691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62692       };
62693     } catch (Dali::DaliException e) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62696       };
62697     } catch (...) {
62698       {
62699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62700       };
62701     }
62702   }
62703
62704   jresult = (void *)result;
62705   return jresult;
62706 }
62707
62708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62709   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62710
62711   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62712   {
62713     try {
62714       delete arg1;
62715     } catch (std::out_of_range& e) {
62716       {
62717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62718       };
62719     } catch (std::exception& e) {
62720       {
62721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62722       };
62723     } catch (Dali::DaliException e) {
62724       {
62725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62726       };
62727     } catch (...) {
62728       {
62729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62730       };
62731     }
62732   }
62733
62734 }
62735
62736
62737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62738   void * jresult ;
62739   Dali::Property::Map *arg1 = 0 ;
62740   Dali::Toolkit::TransitionData result;
62741
62742   arg1 = (Dali::Property::Map *)jarg1;
62743   if (!arg1) {
62744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62745     return 0;
62746   }
62747   {
62748     try {
62749       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62750     } catch (std::out_of_range& e) {
62751       {
62752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62753       };
62754     } catch (std::exception& e) {
62755       {
62756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62757       };
62758     } catch (Dali::DaliException e) {
62759       {
62760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62761       };
62762     } catch (...) {
62763       {
62764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62765       };
62766     }
62767   }
62768
62769   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62770   return jresult;
62771 }
62772
62773
62774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62775   void * jresult ;
62776   Dali::Property::Array *arg1 = 0 ;
62777   Dali::Toolkit::TransitionData result;
62778
62779   arg1 = (Dali::Property::Array *)jarg1;
62780   if (!arg1) {
62781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62782     return 0;
62783   }
62784   {
62785     try {
62786       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62787     } catch (std::out_of_range& e) {
62788       {
62789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62790       };
62791     } catch (std::exception& e) {
62792       {
62793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62794       };
62795     } catch (Dali::DaliException e) {
62796       {
62797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62798       };
62799     } catch (...) {
62800       {
62801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62802       };
62803     }
62804   }
62805
62806   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62807   return jresult;
62808 }
62809
62810
62811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62812   void * jresult ;
62813   Dali::BaseHandle arg1 ;
62814   Dali::BaseHandle *argp1 ;
62815   Dali::Toolkit::TransitionData result;
62816
62817   argp1 = (Dali::BaseHandle *)jarg1;
62818   if (!argp1) {
62819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62820     return 0;
62821   }
62822   arg1 = *argp1;
62823   {
62824     try {
62825       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62826     } catch (std::out_of_range& e) {
62827       {
62828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62829       };
62830     } catch (std::exception& e) {
62831       {
62832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62833       };
62834     } catch (Dali::DaliException e) {
62835       {
62836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62837       };
62838     } catch (...) {
62839       {
62840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62841       };
62842     }
62843   }
62844
62845   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62846   return jresult;
62847 }
62848
62849
62850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62851   void * jresult ;
62852   Dali::Toolkit::TransitionData *arg1 = 0 ;
62853   Dali::Toolkit::TransitionData *result = 0 ;
62854
62855   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62856   if (!arg1) {
62857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62858     return 0;
62859   }
62860   {
62861     try {
62862       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62863     } catch (std::out_of_range& e) {
62864       {
62865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62866       };
62867     } catch (std::exception& e) {
62868       {
62869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62870       };
62871     } catch (Dali::DaliException e) {
62872       {
62873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62874       };
62875     } catch (...) {
62876       {
62877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62878       };
62879     }
62880   }
62881
62882   jresult = (void *)result;
62883   return jresult;
62884 }
62885
62886
62887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62888   void * jresult ;
62889   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62890   Dali::Toolkit::TransitionData *arg2 = 0 ;
62891   Dali::Toolkit::TransitionData *result = 0 ;
62892
62893   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62894   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62895   if (!arg2) {
62896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62897     return 0;
62898   }
62899   {
62900     try {
62901       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62902     } catch (std::out_of_range& e) {
62903       {
62904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62905       };
62906     } catch (std::exception& e) {
62907       {
62908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62909       };
62910     } catch (Dali::DaliException e) {
62911       {
62912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62913       };
62914     } catch (...) {
62915       {
62916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62917       };
62918     }
62919   }
62920
62921   jresult = (void *)result;
62922   return jresult;
62923 }
62924
62925
62926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62927   unsigned long jresult ;
62928   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62929   size_t result;
62930
62931   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62932   {
62933     try {
62934       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62935     } catch (std::out_of_range& e) {
62936       {
62937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62938       };
62939     } catch (std::exception& e) {
62940       {
62941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62942       };
62943     } catch (Dali::DaliException e) {
62944       {
62945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62946       };
62947     } catch (...) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62950       };
62951     }
62952   }
62953
62954   jresult = (unsigned long)result;
62955   return jresult;
62956 }
62957
62958
62959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62960   void * jresult ;
62961   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62962   size_t arg2 ;
62963   Dali::Property::Map result;
62964
62965   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62966   arg2 = (size_t)jarg2;
62967   {
62968     try {
62969       result = (arg1)->GetAnimatorAt(arg2);
62970     } catch (std::out_of_range& e) {
62971       {
62972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62973       };
62974     } catch (std::exception& e) {
62975       {
62976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62977       };
62978     } catch (Dali::DaliException e) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62981       };
62982     } catch (...) {
62983       {
62984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62985       };
62986     }
62987   }
62988
62989   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62990   return jresult;
62991 }
62992
62993
62994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62995   int jresult ;
62996   int result;
62997
62998   {
62999     try {
63000       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63001     } catch (std::out_of_range& e) {
63002       {
63003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63004       };
63005     } catch (std::exception& e) {
63006       {
63007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63008       };
63009     } catch (Dali::DaliException e) {
63010       {
63011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63012       };
63013     } catch (...) {
63014       {
63015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63016       };
63017     }
63018   }
63019
63020   jresult = (int)result;
63021   return jresult;
63022 }
63023
63024
63025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63026   int jresult ;
63027   int result;
63028
63029   {
63030     try {
63031       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63032     } catch (std::out_of_range& e) {
63033       {
63034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63035       };
63036     } catch (std::exception& e) {
63037       {
63038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (Dali::DaliException e) {
63041       {
63042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63043       };
63044     } catch (...) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63047       };
63048     }
63049   }
63050
63051   jresult = (int)result;
63052   return jresult;
63053 }
63054
63055
63056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63057   int jresult ;
63058   int result;
63059
63060   {
63061     try {
63062       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63063     } catch (std::out_of_range& e) {
63064       {
63065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63066       };
63067     } catch (std::exception& e) {
63068       {
63069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63070       };
63071     } catch (Dali::DaliException e) {
63072       {
63073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63074       };
63075     } catch (...) {
63076       {
63077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63078       };
63079     }
63080   }
63081
63082   jresult = (int)result;
63083   return jresult;
63084 }
63085
63086
63087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63088   int jresult ;
63089   int result;
63090
63091   {
63092     try {
63093       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63094     } catch (std::out_of_range& e) {
63095       {
63096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63097       };
63098     } catch (std::exception& e) {
63099       {
63100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63101       };
63102     } catch (Dali::DaliException e) {
63103       {
63104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63105       };
63106     } catch (...) {
63107       {
63108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63109       };
63110     }
63111   }
63112
63113   jresult = (int)result;
63114   return jresult;
63115 }
63116
63117
63118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63119   int jresult ;
63120   int result;
63121
63122   {
63123     try {
63124       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63125     } catch (std::out_of_range& e) {
63126       {
63127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63128       };
63129     } catch (std::exception& e) {
63130       {
63131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63132       };
63133     } catch (Dali::DaliException e) {
63134       {
63135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63136       };
63137     } catch (...) {
63138       {
63139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63140       };
63141     }
63142   }
63143
63144   jresult = (int)result;
63145   return jresult;
63146 }
63147
63148
63149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63150   int jresult ;
63151   int result;
63152
63153   {
63154     try {
63155       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63156     } catch (std::out_of_range& e) {
63157       {
63158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63159       };
63160     } catch (std::exception& e) {
63161       {
63162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63163       };
63164     } catch (Dali::DaliException e) {
63165       {
63166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63167       };
63168     } catch (...) {
63169       {
63170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63171       };
63172     }
63173   }
63174
63175   jresult = (int)result;
63176   return jresult;
63177 }
63178
63179
63180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63181   int jresult ;
63182   int result;
63183
63184   {
63185     try {
63186       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63187     } catch (std::out_of_range& e) {
63188       {
63189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63190       };
63191     } catch (std::exception& e) {
63192       {
63193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63194       };
63195     } catch (Dali::DaliException e) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63198       };
63199     } catch (...) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63202       };
63203     }
63204   }
63205
63206   jresult = (int)result;
63207   return jresult;
63208 }
63209
63210
63211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63212   int jresult ;
63213   int result;
63214
63215   {
63216     try {
63217       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63218     } catch (std::out_of_range& e) {
63219       {
63220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63221       };
63222     } catch (std::exception& e) {
63223       {
63224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63225       };
63226     } catch (Dali::DaliException e) {
63227       {
63228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63229       };
63230     } catch (...) {
63231       {
63232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63233       };
63234     }
63235   }
63236
63237   jresult = (int)result;
63238   return jresult;
63239 }
63240
63241
63242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63243   int jresult ;
63244   int result;
63245
63246   {
63247     try {
63248       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63249     } catch (std::out_of_range& e) {
63250       {
63251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63252       };
63253     } catch (std::exception& e) {
63254       {
63255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63256       };
63257     } catch (Dali::DaliException e) {
63258       {
63259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63260       };
63261     } catch (...) {
63262       {
63263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63264       };
63265     }
63266   }
63267
63268   jresult = (int)result;
63269   return jresult;
63270 }
63271
63272
63273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63274   int jresult ;
63275   int result;
63276
63277   {
63278     try {
63279       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63280     } catch (std::out_of_range& e) {
63281       {
63282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63283       };
63284     } catch (std::exception& e) {
63285       {
63286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63287       };
63288     } catch (Dali::DaliException e) {
63289       {
63290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63291       };
63292     } catch (...) {
63293       {
63294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63295       };
63296     }
63297   }
63298
63299   jresult = (int)result;
63300   return jresult;
63301 }
63302
63303
63304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63305   int jresult ;
63306   int result;
63307
63308   {
63309     try {
63310       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63311     } catch (std::out_of_range& e) {
63312       {
63313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63314       };
63315     } catch (std::exception& e) {
63316       {
63317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63318       };
63319     } catch (Dali::DaliException e) {
63320       {
63321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63322       };
63323     } catch (...) {
63324       {
63325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63326       };
63327     }
63328   }
63329
63330   jresult = (int)result;
63331   return jresult;
63332 }
63333
63334
63335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63336   int jresult ;
63337   int result;
63338
63339   {
63340     try {
63341       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63342     } catch (std::out_of_range& e) {
63343       {
63344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (std::exception& e) {
63347       {
63348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63349       };
63350     } catch (Dali::DaliException e) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63353       };
63354     } catch (...) {
63355       {
63356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63357       };
63358     }
63359   }
63360
63361   jresult = (int)result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63367   int jresult ;
63368   int result;
63369
63370   {
63371     try {
63372       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63380       };
63381     } catch (Dali::DaliException e) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63384       };
63385     } catch (...) {
63386       {
63387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63388       };
63389     }
63390   }
63391
63392   jresult = (int)result;
63393   return jresult;
63394 }
63395
63396
63397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63398   int jresult ;
63399   int result;
63400
63401   {
63402     try {
63403       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63404     } catch (std::out_of_range& e) {
63405       {
63406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63407       };
63408     } catch (std::exception& e) {
63409       {
63410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63411       };
63412     } catch (Dali::DaliException e) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63419       };
63420     }
63421   }
63422
63423   jresult = (int)result;
63424   return jresult;
63425 }
63426
63427
63428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63429   void * jresult ;
63430   Dali::Toolkit::Control result;
63431
63432   {
63433     try {
63434       result = Dali::Toolkit::Internal::Control::New();
63435     } catch (std::out_of_range& e) {
63436       {
63437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (std::exception& e) {
63440       {
63441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63442       };
63443     } catch (Dali::DaliException e) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63450       };
63451     }
63452   }
63453
63454   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63455   return jresult;
63456 }
63457
63458
63459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63460   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63461   std::string *arg2 = 0 ;
63462
63463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63464   if (!jarg2) {
63465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63466     return ;
63467   }
63468   std::string arg2_str(jarg2);
63469   arg2 = &arg2_str;
63470   {
63471     try {
63472       (arg1)->SetStyleName((std::string const &)*arg2);
63473     } catch (std::out_of_range& e) {
63474       {
63475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63476       };
63477     } catch (std::exception& e) {
63478       {
63479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63480       };
63481     } catch (Dali::DaliException e) {
63482       {
63483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63484       };
63485     } catch (...) {
63486       {
63487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63488       };
63489     }
63490   }
63491
63492
63493   //argout typemap for const std::string&
63494
63495 }
63496
63497
63498 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63499   char * jresult ;
63500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63501   std::string *result = 0 ;
63502
63503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63504   {
63505     try {
63506       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63507     } catch (std::out_of_range& e) {
63508       {
63509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63510       };
63511     } catch (std::exception& e) {
63512       {
63513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63514       };
63515     } catch (Dali::DaliException e) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63518       };
63519     } catch (...) {
63520       {
63521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63522       };
63523     }
63524   }
63525
63526   jresult = SWIG_csharp_string_callback(result->c_str());
63527   return jresult;
63528 }
63529
63530
63531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63533   Dali::Vector4 *arg2 = 0 ;
63534
63535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63536   arg2 = (Dali::Vector4 *)jarg2;
63537   if (!arg2) {
63538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63539     return ;
63540   }
63541   {
63542     try {
63543       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63544     } catch (std::out_of_range& e) {
63545       {
63546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63547       };
63548     } catch (std::exception& e) {
63549       {
63550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63551       };
63552     } catch (Dali::DaliException e) {
63553       {
63554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63555       };
63556     } catch (...) {
63557       {
63558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63559       };
63560     }
63561   }
63562
63563 }
63564
63565
63566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63567   void * jresult ;
63568   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63569   Dali::Vector4 result;
63570
63571   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63572   {
63573     try {
63574       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63575     } catch (std::out_of_range& e) {
63576       {
63577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (std::exception& e) {
63580       {
63581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63582       };
63583     } catch (Dali::DaliException e) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63586       };
63587     } catch (...) {
63588       {
63589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63590       };
63591     }
63592   }
63593
63594   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63595   return jresult;
63596 }
63597
63598
63599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63600   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63601   Dali::Image arg2 ;
63602   Dali::Image *argp2 ;
63603
63604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63605   argp2 = (Dali::Image *)jarg2;
63606   if (!argp2) {
63607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63608     return ;
63609   }
63610   arg2 = *argp2;
63611   {
63612     try {
63613       (arg1)->SetBackgroundImage(arg2);
63614     } catch (std::out_of_range& e) {
63615       {
63616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63617       };
63618     } catch (std::exception& e) {
63619       {
63620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63621       };
63622     } catch (Dali::DaliException e) {
63623       {
63624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63625       };
63626     } catch (...) {
63627       {
63628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63629       };
63630     }
63631   }
63632
63633 }
63634
63635
63636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63638   Dali::Property::Map *arg2 = 0 ;
63639
63640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63641   arg2 = (Dali::Property::Map *)jarg2;
63642   if (!arg2) {
63643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63644     return ;
63645   }
63646   {
63647     try {
63648       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63649     } catch (std::out_of_range& e) {
63650       {
63651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63652       };
63653     } catch (std::exception& e) {
63654       {
63655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63656       };
63657     } catch (Dali::DaliException e) {
63658       {
63659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63660       };
63661     } catch (...) {
63662       {
63663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63664       };
63665     }
63666   }
63667
63668 }
63669
63670
63671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63673
63674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63675   {
63676     try {
63677       (arg1)->ClearBackground();
63678     } catch (std::out_of_range& e) {
63679       {
63680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63681       };
63682     } catch (std::exception& e) {
63683       {
63684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63685       };
63686     } catch (Dali::DaliException e) {
63687       {
63688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63689       };
63690     } catch (...) {
63691       {
63692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63693       };
63694     }
63695   }
63696
63697 }
63698
63699
63700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63701   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63702   Dali::Gesture::Type arg2 ;
63703
63704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63705   arg2 = (Dali::Gesture::Type)jarg2;
63706   {
63707     try {
63708       (arg1)->EnableGestureDetection(arg2);
63709     } catch (std::out_of_range& e) {
63710       {
63711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63712       };
63713     } catch (std::exception& e) {
63714       {
63715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63716       };
63717     } catch (Dali::DaliException e) {
63718       {
63719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63720       };
63721     } catch (...) {
63722       {
63723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63724       };
63725     }
63726   }
63727
63728 }
63729
63730
63731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63732   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63733   Dali::Gesture::Type arg2 ;
63734
63735   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63736   arg2 = (Dali::Gesture::Type)jarg2;
63737   {
63738     try {
63739       (arg1)->DisableGestureDetection(arg2);
63740     } catch (std::out_of_range& e) {
63741       {
63742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63743       };
63744     } catch (std::exception& e) {
63745       {
63746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63747       };
63748     } catch (Dali::DaliException e) {
63749       {
63750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63751       };
63752     } catch (...) {
63753       {
63754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63755       };
63756     }
63757   }
63758
63759 }
63760
63761
63762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63763   void * jresult ;
63764   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63765   Dali::PinchGestureDetector result;
63766
63767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63768   {
63769     try {
63770       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63771     } catch (std::out_of_range& e) {
63772       {
63773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63774       };
63775     } catch (std::exception& e) {
63776       {
63777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63778       };
63779     } catch (Dali::DaliException e) {
63780       {
63781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63782       };
63783     } catch (...) {
63784       {
63785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63786       };
63787     }
63788   }
63789
63790   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63791   return jresult;
63792 }
63793
63794
63795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63796   void * jresult ;
63797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63798   Dali::PanGestureDetector result;
63799
63800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63801   {
63802     try {
63803       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63804     } catch (std::out_of_range& e) {
63805       {
63806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63807       };
63808     } catch (std::exception& e) {
63809       {
63810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63811       };
63812     } catch (Dali::DaliException e) {
63813       {
63814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63815       };
63816     } catch (...) {
63817       {
63818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63819       };
63820     }
63821   }
63822
63823   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63824   return jresult;
63825 }
63826
63827
63828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63829   void * jresult ;
63830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63831   Dali::TapGestureDetector result;
63832
63833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63834   {
63835     try {
63836       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63837     } catch (std::out_of_range& e) {
63838       {
63839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63840       };
63841     } catch (std::exception& e) {
63842       {
63843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63844       };
63845     } catch (Dali::DaliException e) {
63846       {
63847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63848       };
63849     } catch (...) {
63850       {
63851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63852       };
63853     }
63854   }
63855
63856   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63857   return jresult;
63858 }
63859
63860
63861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63862   void * jresult ;
63863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63864   Dali::LongPressGestureDetector result;
63865
63866   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63867   {
63868     try {
63869       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63870     } catch (std::out_of_range& e) {
63871       {
63872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63873       };
63874     } catch (std::exception& e) {
63875       {
63876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63877       };
63878     } catch (Dali::DaliException e) {
63879       {
63880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63881       };
63882     } catch (...) {
63883       {
63884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63885       };
63886     }
63887   }
63888
63889   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63890   return jresult;
63891 }
63892
63893
63894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63896   bool arg2 ;
63897
63898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63899   arg2 = jarg2 ? true : false;
63900   {
63901     try {
63902       (arg1)->SetKeyboardNavigationSupport(arg2);
63903     } catch (std::out_of_range& e) {
63904       {
63905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63906       };
63907     } catch (std::exception& e) {
63908       {
63909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63910       };
63911     } catch (Dali::DaliException e) {
63912       {
63913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63914       };
63915     } catch (...) {
63916       {
63917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63918       };
63919     }
63920   }
63921
63922 }
63923
63924
63925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63926   unsigned int jresult ;
63927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63928   bool result;
63929
63930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63931   {
63932     try {
63933       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63934     } catch (std::out_of_range& e) {
63935       {
63936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63937       };
63938     } catch (std::exception& e) {
63939       {
63940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63941       };
63942     } catch (Dali::DaliException e) {
63943       {
63944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63945       };
63946     } catch (...) {
63947       {
63948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63949       };
63950     }
63951   }
63952
63953   jresult = result;
63954   return jresult;
63955 }
63956
63957
63958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63960
63961   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63962   {
63963     try {
63964       (arg1)->SetKeyInputFocus();
63965     } catch (std::out_of_range& e) {
63966       {
63967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63968       };
63969     } catch (std::exception& e) {
63970       {
63971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63972       };
63973     } catch (Dali::DaliException e) {
63974       {
63975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63976       };
63977     } catch (...) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63980       };
63981     }
63982   }
63983
63984 }
63985
63986
63987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63988   unsigned int jresult ;
63989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63990   bool result;
63991
63992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63993   {
63994     try {
63995       result = (bool)(arg1)->HasKeyInputFocus();
63996     } catch (std::out_of_range& e) {
63997       {
63998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63999       };
64000     } catch (std::exception& e) {
64001       {
64002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64003       };
64004     } catch (Dali::DaliException e) {
64005       {
64006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64007       };
64008     } catch (...) {
64009       {
64010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64011       };
64012     }
64013   }
64014
64015   jresult = result;
64016   return jresult;
64017 }
64018
64019
64020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64021   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64022
64023   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64024   {
64025     try {
64026       (arg1)->ClearKeyInputFocus();
64027     } catch (std::out_of_range& e) {
64028       {
64029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64030       };
64031     } catch (std::exception& e) {
64032       {
64033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64034       };
64035     } catch (Dali::DaliException e) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64038       };
64039     } catch (...) {
64040       {
64041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64042       };
64043     }
64044   }
64045
64046 }
64047
64048
64049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64051   bool arg2 ;
64052
64053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64054   arg2 = jarg2 ? true : false;
64055   {
64056     try {
64057       (arg1)->SetAsKeyboardFocusGroup(arg2);
64058     } catch (std::out_of_range& e) {
64059       {
64060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64061       };
64062     } catch (std::exception& e) {
64063       {
64064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64065       };
64066     } catch (Dali::DaliException e) {
64067       {
64068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64069       };
64070     } catch (...) {
64071       {
64072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64073       };
64074     }
64075   }
64076
64077 }
64078
64079
64080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64081   unsigned int jresult ;
64082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64083   bool result;
64084
64085   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64086   {
64087     try {
64088       result = (bool)(arg1)->IsKeyboardFocusGroup();
64089     } catch (std::out_of_range& e) {
64090       {
64091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (std::exception& e) {
64094       {
64095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64096       };
64097     } catch (Dali::DaliException e) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64100       };
64101     } catch (...) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64104       };
64105     }
64106   }
64107
64108   jresult = result;
64109   return jresult;
64110 }
64111
64112
64113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64114   void * jresult ;
64115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64116   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64117
64118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64119   {
64120     try {
64121       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64122     } catch (std::out_of_range& e) {
64123       {
64124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64125       };
64126     } catch (std::exception& e) {
64127       {
64128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64129       };
64130     } catch (Dali::DaliException e) {
64131       {
64132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64133       };
64134     } catch (...) {
64135       {
64136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64137       };
64138     }
64139   }
64140
64141   jresult = (void *)result;
64142   return jresult;
64143 }
64144
64145
64146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64147   void * jresult ;
64148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64149   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64150
64151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64152   {
64153     try {
64154       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64155     } catch (std::out_of_range& e) {
64156       {
64157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64158       };
64159     } catch (std::exception& e) {
64160       {
64161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64162       };
64163     } catch (Dali::DaliException e) {
64164       {
64165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64166       };
64167     } catch (...) {
64168       {
64169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64170       };
64171     }
64172   }
64173
64174   jresult = (void *)result;
64175   return jresult;
64176 }
64177
64178
64179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64180   void * jresult ;
64181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64182   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64183
64184   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64185   {
64186     try {
64187       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64188     } catch (std::out_of_range& e) {
64189       {
64190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64191       };
64192     } catch (std::exception& e) {
64193       {
64194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64195       };
64196     } catch (Dali::DaliException e) {
64197       {
64198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64199       };
64200     } catch (...) {
64201       {
64202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64203       };
64204     }
64205   }
64206
64207   jresult = (void *)result;
64208   return jresult;
64209 }
64210
64211
64212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64213   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64214   int arg2 ;
64215   SwigDirector_ViewImpl *darg = 0;
64216
64217   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64218   arg2 = (int)jarg2;
64219   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64220   if(!darg) {
64221     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64222     return;
64223   }
64224   {
64225     try {
64226       if(darg) {
64227         (darg)->OnStageConnection(arg2);
64228       }
64229     } catch (std::out_of_range& e) {
64230       {
64231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64232       };
64233     } catch (std::exception& e) {
64234       {
64235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64236       };
64237     } catch (Dali::DaliException e) {
64238       {
64239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64240       };
64241     } catch (...) {
64242       {
64243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64244       };
64245     }
64246   }
64247
64248 }
64249
64250
64251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64253   int arg2 ;
64254   SwigDirector_ViewImpl *darg = 0;
64255
64256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64257   arg2 = (int)jarg2;
64258   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64259   if(!darg) {
64260     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64261     return;
64262   }
64263   {
64264     try {
64265       if(darg) {
64266         (darg)->OnStageConnectionSwigPublic(arg2);
64267       }
64268     } catch (std::out_of_range& e) {
64269       {
64270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64271       };
64272     } catch (std::exception& e) {
64273       {
64274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64275       };
64276     } catch (Dali::DaliException e) {
64277       {
64278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64279       };
64280     } catch (...) {
64281       {
64282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64283       };
64284     }
64285   }
64286
64287 }
64288
64289
64290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64292   SwigDirector_ViewImpl *darg = 0;
64293
64294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64295   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64296   if(!darg) {
64297     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64298     return;
64299   }
64300   {
64301     try {
64302       if(darg) {
64303         (darg)->OnStageDisconnection();
64304       }
64305     } catch (std::out_of_range& e) {
64306       {
64307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64308       };
64309     } catch (std::exception& e) {
64310       {
64311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64312       };
64313     } catch (Dali::DaliException e) {
64314       {
64315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64316       };
64317     } catch (...) {
64318       {
64319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64320       };
64321     }
64322   }
64323
64324 }
64325
64326
64327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64329   SwigDirector_ViewImpl *darg = 0;
64330
64331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64333   if(!darg) {
64334     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64335     return;
64336   }
64337   {
64338     try {
64339       if(darg) {
64340         (darg)->OnStageDisconnectionSwigPublic();
64341       }
64342     } catch (std::out_of_range& e) {
64343       {
64344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64345       };
64346     } catch (std::exception& e) {
64347       {
64348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64349       };
64350     } catch (Dali::DaliException e) {
64351       {
64352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64353       };
64354     } catch (...) {
64355       {
64356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64357       };
64358     }
64359   }
64360
64361 }
64362
64363
64364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64366   Dali::Actor *arg2 = 0 ;
64367   SwigDirector_ViewImpl *darg = 0;
64368
64369   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64370   arg2 = (Dali::Actor *)jarg2;
64371   if (!arg2) {
64372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64373     return ;
64374   }
64375   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64376   if(!darg) {
64377     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64378     return;
64379   }
64380   {
64381     try {
64382       if(darg) {
64383         (darg)->OnChildAdd(*arg2);
64384       }
64385     } catch (std::out_of_range& e) {
64386       {
64387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64388       };
64389     } catch (std::exception& e) {
64390       {
64391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64392       };
64393     } catch (Dali::DaliException e) {
64394       {
64395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64396       };
64397     } catch (...) {
64398       {
64399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64400       };
64401     }
64402   }
64403
64404 }
64405
64406
64407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64409   Dali::Actor *arg2 = 0 ;
64410   SwigDirector_ViewImpl *darg = 0;
64411
64412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64413   arg2 = (Dali::Actor *)jarg2;
64414   if (!arg2) {
64415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64416     return ;
64417   }
64418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64419   if(!darg) {
64420     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64421     return;
64422   }
64423   {
64424     try {
64425       if(darg) {
64426           (darg)->OnChildAddSwigPublic(*arg2);
64427       }
64428     } catch (std::out_of_range& e) {
64429       {
64430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64431       };
64432     } catch (std::exception& e) {
64433       {
64434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64435       };
64436     } catch (Dali::DaliException e) {
64437       {
64438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64439       };
64440     } catch (...) {
64441       {
64442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64443       };
64444     }
64445   }
64446
64447 }
64448
64449
64450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64452   Dali::Actor *arg2 = 0 ;
64453   SwigDirector_ViewImpl *darg = 0;
64454
64455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64456   arg2 = (Dali::Actor *)jarg2;
64457   if (!arg2) {
64458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64459     return ;
64460   }
64461   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64462   if(!darg) {
64463     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64464     return;
64465   }
64466   {
64467     try {
64468       if(darg) {
64469         (darg)->OnChildRemove(*arg2);
64470       }
64471     } catch (std::out_of_range& e) {
64472       {
64473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64474       };
64475     } catch (std::exception& e) {
64476       {
64477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64478       };
64479     } catch (Dali::DaliException e) {
64480       {
64481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64482       };
64483     } catch (...) {
64484       {
64485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64486       };
64487     }
64488   }
64489
64490 }
64491
64492
64493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64495   Dali::Actor *arg2 = 0 ;
64496   SwigDirector_ViewImpl *darg = 0;
64497
64498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64499   arg2 = (Dali::Actor *)jarg2;
64500   if (!arg2) {
64501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64502     return ;
64503   }
64504   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64505   if(!darg) {
64506     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64507     return;
64508   }
64509   {
64510     try {
64511       if(darg) {
64512         (darg)->OnChildRemoveSwigPublic(*arg2);
64513       }
64514     } catch (std::out_of_range& e) {
64515       {
64516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64517       };
64518     } catch (std::exception& e) {
64519       {
64520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64521       };
64522     } catch (Dali::DaliException e) {
64523       {
64524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64525       };
64526     } catch (...) {
64527       {
64528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64529       };
64530     }
64531   }
64532
64533 }
64534
64535
64536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64538   Dali::Property::Index arg2 ;
64539   Dali::Property::Value arg3 ;
64540   Dali::Property::Value *argp3 ;
64541   SwigDirector_ViewImpl *darg = 0;
64542
64543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64544   arg2 = (Dali::Property::Index)jarg2;
64545   argp3 = (Dali::Property::Value *)jarg3;
64546   if (!argp3) {
64547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64548     return ;
64549   }
64550   arg3 = *argp3;
64551   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64552   if (!darg) {
64553     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64554     return;
64555   }
64556   {
64557     try {
64558       (darg)->OnPropertySet(arg2,arg3);
64559     } catch (std::out_of_range& e) {
64560       {
64561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64562       };
64563     } catch (std::exception& e) {
64564       {
64565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64566       };
64567     } catch (Dali::DaliException e) {
64568       {
64569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64570       };
64571     } catch (...) {
64572       {
64573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64574       };
64575     }
64576   }
64577
64578 }
64579
64580
64581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64583   Dali::Property::Index arg2 ;
64584   Dali::Property::Value arg3 ;
64585   Dali::Property::Value *argp3 ;
64586   SwigDirector_ViewImpl *darg = 0;
64587
64588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64589   arg2 = (Dali::Property::Index)jarg2;
64590   argp3 = (Dali::Property::Value *)jarg3;
64591   if (!argp3) {
64592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64593     return ;
64594   }
64595   arg3 = *argp3;
64596   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64597   if (!darg) {
64598     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64599     return;
64600   }
64601   {
64602     try {
64603       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64604     } catch (std::out_of_range& e) {
64605       {
64606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64607       };
64608     } catch (std::exception& e) {
64609       {
64610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64611       };
64612     } catch (Dali::DaliException e) {
64613       {
64614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64615       };
64616     } catch (...) {
64617       {
64618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64619       };
64620     }
64621   }
64622
64623 }
64624
64625
64626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64628   Dali::Vector3 *arg2 = 0 ;
64629   SwigDirector_ViewImpl *darg = 0;
64630
64631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64632   arg2 = (Dali::Vector3 *)jarg2;
64633   if (!arg2) {
64634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64635     return ;
64636   }
64637   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64638   if (!darg) {
64639     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64640     return;
64641   }
64642   {
64643     try {
64644       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64645     } catch (std::out_of_range& e) {
64646       {
64647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64648       };
64649     } catch (std::exception& e) {
64650       {
64651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64652       };
64653     } catch (Dali::DaliException e) {
64654       {
64655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64656       };
64657     } catch (...) {
64658       {
64659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64660       };
64661     }
64662   }
64663
64664 }
64665
64666
64667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64669   Dali::Vector3 *arg2 = 0 ;
64670   SwigDirector_ViewImpl *darg = 0;
64671
64672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64673   arg2 = (Dali::Vector3 *)jarg2;
64674   if (!arg2) {
64675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64676     return ;
64677   }
64678   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64679   if (!darg) {
64680     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64681     return;
64682   }
64683   {
64684     try {
64685       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64686     } catch (std::out_of_range& e) {
64687       {
64688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64689       };
64690     } catch (std::exception& e) {
64691       {
64692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64693       };
64694     } catch (Dali::DaliException e) {
64695       {
64696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64697       };
64698     } catch (...) {
64699       {
64700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64701       };
64702     }
64703   }
64704
64705 }
64706
64707
64708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64710   Dali::Animation *arg2 = 0 ;
64711   Dali::Vector3 *arg3 = 0 ;
64712   SwigDirector_ViewImpl *darg = 0;
64713
64714   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64715   arg2 = (Dali::Animation *)jarg2;
64716   if (!arg2) {
64717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64718     return ;
64719   }
64720   arg3 = (Dali::Vector3 *)jarg3;
64721   if (!arg3) {
64722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64723     return ;
64724   }
64725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64726   if (!darg) {
64727     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64728     return;
64729   }
64730   {
64731     try {
64732       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64733     } catch (std::out_of_range& e) {
64734       {
64735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64736       };
64737     } catch (std::exception& e) {
64738       {
64739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64740       };
64741     } catch (Dali::DaliException e) {
64742       {
64743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64744       };
64745     } catch (...) {
64746       {
64747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64748       };
64749     }
64750   }
64751
64752 }
64753
64754
64755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64756   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64757   Dali::Animation *arg2 = 0 ;
64758   Dali::Vector3 *arg3 = 0 ;
64759   SwigDirector_ViewImpl *darg = 0;
64760
64761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64762   arg2 = (Dali::Animation *)jarg2;
64763   if (!arg2) {
64764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64765     return ;
64766   }
64767   arg3 = (Dali::Vector3 *)jarg3;
64768   if (!arg3) {
64769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64770     return ;
64771   }
64772   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64773   if (!darg) {
64774     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64775     return;
64776   }
64777   {
64778     try {
64779       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64780     } catch (std::out_of_range& e) {
64781       {
64782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64783       };
64784     } catch (std::exception& e) {
64785       {
64786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64787       };
64788     } catch (Dali::DaliException e) {
64789       {
64790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64791       };
64792     } catch (...) {
64793       {
64794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64795       };
64796     }
64797   }
64798
64799 }
64800
64801
64802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64803   unsigned int jresult ;
64804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64805   Dali::TouchEvent *arg2 = 0 ;
64806   SwigDirector_ViewImpl *darg = 0;
64807   bool result;
64808
64809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64810   arg2 = (Dali::TouchEvent *)jarg2;
64811   if (!arg2) {
64812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64813     return 0;
64814   }
64815   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64816   if (!darg) {
64817     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64818     return 0;
64819   }
64820   {
64821     try {
64822       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64823     } catch (std::out_of_range& e) {
64824       {
64825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64826       };
64827     } catch (std::exception& e) {
64828       {
64829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64830       };
64831     } catch (Dali::DaliException e) {
64832       {
64833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64834       };
64835     } catch (...) {
64836       {
64837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64838       };
64839     }
64840   }
64841
64842   jresult = result;
64843   return jresult;
64844 }
64845
64846
64847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64848   unsigned int jresult ;
64849   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64850   Dali::TouchEvent *arg2 = 0 ;
64851   SwigDirector_ViewImpl *darg = 0;
64852   bool result;
64853
64854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64855   arg2 = (Dali::TouchEvent *)jarg2;
64856   if (!arg2) {
64857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64858     return 0;
64859   }
64860   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64861   if (!darg) {
64862     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64863     return 0;
64864   }
64865   {
64866     try {
64867       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64868     } catch (std::out_of_range& e) {
64869       {
64870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64871       };
64872     } catch (std::exception& e) {
64873       {
64874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64875       };
64876     } catch (Dali::DaliException e) {
64877       {
64878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64879       };
64880     } catch (...) {
64881       {
64882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64883       };
64884     }
64885   }
64886
64887   jresult = result;
64888   return jresult;
64889 }
64890
64891
64892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64893   unsigned int jresult ;
64894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64895   Dali::HoverEvent *arg2 = 0 ;
64896   SwigDirector_ViewImpl *darg = 0;
64897   bool result;
64898
64899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64900   arg2 = (Dali::HoverEvent *)jarg2;
64901   if (!arg2) {
64902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64903     return 0;
64904   }
64905   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64906   if (!darg) {
64907     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64908     return 0;
64909   }
64910   {
64911     try {
64912       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64913     } catch (std::out_of_range& e) {
64914       {
64915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64916       };
64917     } catch (std::exception& e) {
64918       {
64919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64920       };
64921     } catch (Dali::DaliException e) {
64922       {
64923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64924       };
64925     } catch (...) {
64926       {
64927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64928       };
64929     }
64930   }
64931
64932   jresult = result;
64933   return jresult;
64934 }
64935
64936
64937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64938   unsigned int jresult ;
64939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64940   Dali::HoverEvent *arg2 = 0 ;
64941   SwigDirector_ViewImpl *darg = 0;
64942   bool result;
64943
64944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64945   arg2 = (Dali::HoverEvent *)jarg2;
64946   if (!arg2) {
64947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64948     return 0;
64949   }
64950   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64951   if (!darg) {
64952     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64953     return 0;
64954   }
64955   {
64956     try {
64957       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64958     } catch (std::out_of_range& e) {
64959       {
64960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64961       };
64962     } catch (std::exception& e) {
64963       {
64964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64965       };
64966     } catch (Dali::DaliException e) {
64967       {
64968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64969       };
64970     } catch (...) {
64971       {
64972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64973       };
64974     }
64975   }
64976
64977   jresult = result;
64978   return jresult;
64979 }
64980
64981
64982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64983   unsigned int jresult ;
64984   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64985   Dali::KeyEvent *arg2 = 0 ;
64986   SwigDirector_ViewImpl *darg = 0;
64987   bool result;
64988
64989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64990   arg2 = (Dali::KeyEvent *)jarg2;
64991   if (!arg2) {
64992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64993     return 0;
64994   }
64995   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64996   if (!darg) {
64997     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64998     return 0;
64999   }
65000   {
65001     try {
65002       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65003     } catch (std::out_of_range& e) {
65004       {
65005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65006       };
65007     } catch (std::exception& e) {
65008       {
65009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (Dali::DaliException e) {
65012       {
65013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65014       };
65015     } catch (...) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65018       };
65019     }
65020   }
65021
65022   jresult = result;
65023   return jresult;
65024 }
65025
65026
65027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65028   unsigned int jresult ;
65029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65030   Dali::KeyEvent *arg2 = 0 ;
65031   SwigDirector_ViewImpl *darg = 0;
65032   bool result;
65033
65034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65035   arg2 = (Dali::KeyEvent *)jarg2;
65036   if (!arg2) {
65037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65038     return 0;
65039   }
65040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65041   if (!darg) {
65042     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65043     return 0;
65044   }
65045   {
65046     try {
65047       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65048     } catch (std::out_of_range& e) {
65049       {
65050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65051       };
65052     } catch (std::exception& e) {
65053       {
65054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65055       };
65056     } catch (Dali::DaliException e) {
65057       {
65058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65059       };
65060     } catch (...) {
65061       {
65062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65063       };
65064     }
65065   }
65066
65067   jresult = result;
65068   return jresult;
65069 }
65070
65071
65072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65073   unsigned int jresult ;
65074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65075   Dali::WheelEvent *arg2 = 0 ;
65076   SwigDirector_ViewImpl *darg = 0;
65077   bool result;
65078
65079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65080   arg2 = (Dali::WheelEvent *)jarg2;
65081   if (!arg2) {
65082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65083     return 0;
65084   }
65085   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65086   if (!darg) {
65087     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65088     return 0;
65089   }
65090   {
65091     try {
65092       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65093     } catch (std::out_of_range& e) {
65094       {
65095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65096       };
65097     } catch (std::exception& e) {
65098       {
65099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65100       };
65101     } catch (Dali::DaliException e) {
65102       {
65103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65104       };
65105     } catch (...) {
65106       {
65107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65108       };
65109     }
65110   }
65111
65112   jresult = result;
65113   return jresult;
65114 }
65115
65116
65117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65118   unsigned int jresult ;
65119   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65120   Dali::WheelEvent *arg2 = 0 ;
65121   SwigDirector_ViewImpl *darg = 0;
65122   bool result;
65123
65124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65125   arg2 = (Dali::WheelEvent *)jarg2;
65126   if (!arg2) {
65127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65128     return 0;
65129   }
65130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65131   if (!darg) {
65132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65133     return 0;
65134   }
65135   {
65136     try {
65137       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65138     } catch (std::out_of_range& e) {
65139       {
65140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65141       };
65142     } catch (std::exception& e) {
65143       {
65144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65145       };
65146     } catch (Dali::DaliException e) {
65147       {
65148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65149       };
65150     } catch (...) {
65151       {
65152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65153       };
65154     }
65155   }
65156
65157   jresult = result;
65158   return jresult;
65159 }
65160
65161
65162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65164   Dali::Vector2 *arg2 = 0 ;
65165   Dali::RelayoutContainer *arg3 = 0 ;
65166   SwigDirector_ViewImpl *darg = 0;
65167
65168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65169   arg2 = (Dali::Vector2 *)jarg2;
65170   if (!arg2) {
65171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65172     return ;
65173   }
65174   arg3 = (Dali::RelayoutContainer *)jarg3;
65175   if (!arg3) {
65176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65177     return ;
65178   }
65179   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65180   if (!darg) {
65181     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65182     return;
65183   }
65184   {
65185     try {
65186       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65187     } catch (std::out_of_range& e) {
65188       {
65189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65190       };
65191     } catch (std::exception& e) {
65192       {
65193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65194       };
65195     } catch (Dali::DaliException e) {
65196       {
65197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65198       };
65199     } catch (...) {
65200       {
65201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65202       };
65203     }
65204   }
65205
65206 }
65207
65208
65209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65211   Dali::Vector2 *arg2 = 0 ;
65212   Dali::RelayoutContainer *arg3 = 0 ;
65213   SwigDirector_ViewImpl *darg = 0;
65214
65215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65216   arg2 = (Dali::Vector2 *)jarg2;
65217   if (!arg2) {
65218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65219     return ;
65220   }
65221   arg3 = (Dali::RelayoutContainer *)jarg3;
65222   if (!arg3) {
65223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65224     return ;
65225   }
65226   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65227   if (!darg) {
65228     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65229     return;
65230   }
65231   {
65232     try {
65233       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65234     } catch (std::out_of_range& e) {
65235       {
65236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65237       };
65238     } catch (std::exception& e) {
65239       {
65240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65241       };
65242     } catch (Dali::DaliException e) {
65243       {
65244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65245       };
65246     } catch (...) {
65247       {
65248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65249       };
65250     }
65251   }
65252
65253 }
65254
65255
65256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65258   Dali::ResizePolicy::Type arg2 ;
65259   Dali::Dimension::Type arg3 ;
65260   SwigDirector_ViewImpl *darg = 0;
65261
65262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65263   arg2 = (Dali::ResizePolicy::Type)jarg2;
65264   arg3 = (Dali::Dimension::Type)jarg3;
65265   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65266   if (!darg) {
65267     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65268     return;
65269   }
65270   {
65271     try {
65272       (darg)->OnSetResizePolicy(arg2,arg3);
65273     } catch (std::out_of_range& e) {
65274       {
65275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65276       };
65277     } catch (std::exception& e) {
65278       {
65279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65280       };
65281     } catch (Dali::DaliException e) {
65282       {
65283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65284       };
65285     } catch (...) {
65286       {
65287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65288       };
65289     }
65290   }
65291
65292 }
65293
65294
65295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65297   Dali::ResizePolicy::Type arg2 ;
65298   Dali::Dimension::Type arg3 ;
65299   SwigDirector_ViewImpl *darg = 0;
65300
65301   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65302   arg2 = (Dali::ResizePolicy::Type)jarg2;
65303   arg3 = (Dali::Dimension::Type)jarg3;
65304   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65305   if (!darg) {
65306     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65307     return;
65308   }
65309   {
65310     try {
65311       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65312     } catch (std::out_of_range& e) {
65313       {
65314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65315       };
65316     } catch (std::exception& e) {
65317       {
65318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65319       };
65320     } catch (Dali::DaliException e) {
65321       {
65322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65323       };
65324     } catch (...) {
65325       {
65326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65327       };
65328     }
65329   }
65330
65331 }
65332
65333
65334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65335   void * jresult ;
65336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65337   SwigDirector_ViewImpl *darg = 0;
65338   Dali::Vector3 result;
65339
65340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65341   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65342   if (!darg) {
65343     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65344     return 0;
65345   }
65346   {
65347     try {
65348       result = (darg)->GetNaturalSize();
65349     } catch (std::out_of_range& e) {
65350       {
65351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65352       };
65353     } catch (std::exception& e) {
65354       {
65355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65356       };
65357     } catch (Dali::DaliException e) {
65358       {
65359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65360       };
65361     } catch (...) {
65362       {
65363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65364       };
65365     }
65366   }
65367
65368   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65369   return jresult;
65370 }
65371
65372
65373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65374   void * jresult ;
65375   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65376   SwigDirector_ViewImpl *darg = 0;
65377   Dali::Vector3 result;
65378
65379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65380   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65381   if (!darg) {
65382     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65383     return 0;
65384   }
65385   {
65386     try {
65387       result = (darg)->GetNaturalSizeSwigPublic();
65388     } catch (std::out_of_range& e) {
65389       {
65390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65391       };
65392     } catch (std::exception& e) {
65393       {
65394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65395       };
65396     } catch (Dali::DaliException e) {
65397       {
65398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65399       };
65400     } catch (...) {
65401       {
65402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65403       };
65404     }
65405   }
65406
65407   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65408   return jresult;
65409 }
65410
65411
65412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65413   float jresult ;
65414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65415   Dali::Actor *arg2 = 0 ;
65416   Dali::Dimension::Type arg3 ;
65417   SwigDirector_ViewImpl *darg = 0;
65418   float result;
65419
65420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65421   arg2 = (Dali::Actor *)jarg2;
65422   if (!arg2) {
65423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65424     return 0;
65425   }
65426   arg3 = (Dali::Dimension::Type)jarg3;
65427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65428   if (!darg) {
65429     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65430     return 0;
65431   }
65432   {
65433     try {
65434       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65435     } catch (std::out_of_range& e) {
65436       {
65437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65438       };
65439     } catch (std::exception& e) {
65440       {
65441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65442       };
65443     } catch (Dali::DaliException e) {
65444       {
65445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65446       };
65447     } catch (...) {
65448       {
65449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65450       };
65451     }
65452   }
65453
65454   jresult = result;
65455   return jresult;
65456 }
65457
65458
65459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65460   float jresult ;
65461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65462   Dali::Actor *arg2 = 0 ;
65463   Dali::Dimension::Type arg3 ;
65464   SwigDirector_ViewImpl *darg = 0;
65465   float result;
65466
65467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65468   arg2 = (Dali::Actor *)jarg2;
65469   if (!arg2) {
65470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65471     return 0;
65472   }
65473   arg3 = (Dali::Dimension::Type)jarg3;
65474   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65475   if (!darg) {
65476     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65477     return 0;
65478   }
65479   {
65480     try {
65481       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65482     } catch (std::out_of_range& e) {
65483       {
65484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65485       };
65486     } catch (std::exception& e) {
65487       {
65488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65489       };
65490     } catch (Dali::DaliException e) {
65491       {
65492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65493       };
65494     } catch (...) {
65495       {
65496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65497       };
65498     }
65499   }
65500
65501   jresult = result;
65502   return jresult;
65503 }
65504
65505
65506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65507   float jresult ;
65508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65509   float arg2 ;
65510   SwigDirector_ViewImpl *darg = 0;
65511   float result;
65512
65513   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65514   arg2 = (float)jarg2;
65515   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65516   if (!darg) {
65517     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65518     return 0;
65519   }
65520   {
65521     try {
65522       result = (float)(darg)->GetHeightForWidth(arg2);
65523     } catch (std::out_of_range& e) {
65524       {
65525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65526       };
65527     } catch (std::exception& e) {
65528       {
65529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65530       };
65531     } catch (Dali::DaliException e) {
65532       {
65533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65534       };
65535     } catch (...) {
65536       {
65537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65538       };
65539     }
65540   }
65541
65542   jresult = result;
65543   return jresult;
65544 }
65545
65546
65547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65548   float jresult ;
65549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65550   float arg2 ;
65551   SwigDirector_ViewImpl *darg = 0;
65552   float result;
65553
65554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65555   arg2 = (float)jarg2;
65556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65557   if (!darg) {
65558     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65559     return 0;
65560   }
65561   {
65562     try {
65563       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65564     } catch (std::out_of_range& e) {
65565       {
65566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65567       };
65568     } catch (std::exception& e) {
65569       {
65570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65571       };
65572     } catch (Dali::DaliException e) {
65573       {
65574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65575       };
65576     } catch (...) {
65577       {
65578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65579       };
65580     }
65581   }
65582
65583   jresult = result;
65584   return jresult;
65585 }
65586
65587
65588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65589   float jresult ;
65590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65591   float arg2 ;
65592   SwigDirector_ViewImpl *darg = 0;
65593   float result;
65594
65595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65596   arg2 = (float)jarg2;
65597   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65598   if (!darg) {
65599     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65600     return 0;
65601   }
65602   {
65603     try {
65604       result = (float)(darg)->GetWidthForHeight(arg2);
65605     } catch (std::out_of_range& e) {
65606       {
65607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65608       };
65609     } catch (std::exception& e) {
65610       {
65611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65612       };
65613     } catch (Dali::DaliException e) {
65614       {
65615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65616       };
65617     } catch (...) {
65618       {
65619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65620       };
65621     }
65622   }
65623
65624   jresult = result;
65625   return jresult;
65626 }
65627
65628
65629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65630   float jresult ;
65631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65632   float arg2 ;
65633   SwigDirector_ViewImpl *darg = 0;
65634   float result;
65635
65636   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65637   arg2 = (float)jarg2;
65638   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65639   if (!darg) {
65640     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65641     return 0;
65642   }
65643   {
65644     try {
65645       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65646     } catch (std::out_of_range& e) {
65647       {
65648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65649       };
65650     } catch (std::exception& e) {
65651       {
65652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65653       };
65654     } catch (Dali::DaliException e) {
65655       {
65656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65657       };
65658     } catch (...) {
65659       {
65660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65661       };
65662     }
65663   }
65664
65665   jresult = result;
65666   return jresult;
65667 }
65668
65669
65670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65671   unsigned int jresult ;
65672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65673   Dali::Dimension::Type arg2 ;
65674   SwigDirector_ViewImpl *darg = 0;
65675   bool result;
65676
65677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65678   arg2 = (Dali::Dimension::Type)jarg2;
65679   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65680   if (!darg) {
65681     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65682     return 0;
65683   }
65684   {
65685     try {
65686       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65687     } catch (std::out_of_range& e) {
65688       {
65689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65690       };
65691     } catch (std::exception& e) {
65692       {
65693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65694       };
65695     } catch (Dali::DaliException e) {
65696       {
65697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65698       };
65699     } catch (...) {
65700       {
65701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65702       };
65703     }
65704   }
65705
65706   jresult = result;
65707   return jresult;
65708 }
65709
65710
65711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65712   unsigned int jresult ;
65713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65714   Dali::Dimension::Type arg2 ;
65715   SwigDirector_ViewImpl *darg = 0;
65716   bool result;
65717
65718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65719   arg2 = (Dali::Dimension::Type)jarg2;
65720   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65721   if (!darg) {
65722     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65723     return 0;
65724   }
65725   {
65726     try {
65727       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65728     } catch (std::out_of_range& e) {
65729       {
65730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65731       };
65732     } catch (std::exception& e) {
65733       {
65734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65735       };
65736     } catch (Dali::DaliException e) {
65737       {
65738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65739       };
65740     } catch (...) {
65741       {
65742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65743       };
65744     }
65745   }
65746
65747   jresult = result;
65748   return jresult;
65749 }
65750
65751
65752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65753   unsigned int jresult ;
65754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65755   SwigDirector_ViewImpl *darg = 0;
65756   bool result;
65757
65758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65759   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65760   if (!darg) {
65761     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65762     return 0;
65763   }
65764   {
65765     try {
65766       result = (bool)(darg)->RelayoutDependentOnChildren();
65767     } catch (std::out_of_range& e) {
65768       {
65769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65770       };
65771     } catch (std::exception& e) {
65772       {
65773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65774       };
65775     } catch (Dali::DaliException e) {
65776       {
65777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65778       };
65779     } catch (...) {
65780       {
65781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65782       };
65783     }
65784   }
65785
65786   jresult = result;
65787   return jresult;
65788 }
65789
65790
65791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65792   unsigned int jresult ;
65793   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65794   SwigDirector_ViewImpl *darg = 0;
65795   bool result;
65796
65797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65798   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65799   if (!darg) {
65800     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65801     return 0;
65802   }
65803   {
65804     try {
65805       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65806     } catch (std::out_of_range& e) {
65807       {
65808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65809       };
65810     } catch (std::exception& e) {
65811       {
65812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65813       };
65814     } catch (Dali::DaliException e) {
65815       {
65816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65817       };
65818     } catch (...) {
65819       {
65820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65821       };
65822     }
65823   }
65824
65825   jresult = result;
65826   return jresult;
65827 }
65828
65829
65830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65832   Dali::Dimension::Type arg2 ;
65833   SwigDirector_ViewImpl *darg = 0;
65834
65835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65836   arg2 = (Dali::Dimension::Type)jarg2;
65837   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65838   if (!darg) {
65839     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65840     return;
65841   }
65842   {
65843     try {
65844       (darg)->OnCalculateRelayoutSize(arg2);
65845     } catch (std::out_of_range& e) {
65846       {
65847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65848       };
65849     } catch (std::exception& e) {
65850       {
65851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65852       };
65853     } catch (Dali::DaliException e) {
65854       {
65855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65856       };
65857     } catch (...) {
65858       {
65859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65860       };
65861     }
65862   }
65863
65864 }
65865
65866
65867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65869   Dali::Dimension::Type arg2 ;
65870   SwigDirector_ViewImpl *darg = 0;
65871
65872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65873   arg2 = (Dali::Dimension::Type)jarg2;
65874   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65875   if (!darg) {
65876     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65877     return;
65878   }
65879   {
65880     try {
65881       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65882     } catch (std::out_of_range& e) {
65883       {
65884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65885       };
65886     } catch (std::exception& e) {
65887       {
65888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65889       };
65890     } catch (Dali::DaliException e) {
65891       {
65892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65893       };
65894     } catch (...) {
65895       {
65896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65897       };
65898     }
65899   }
65900
65901 }
65902
65903
65904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65905   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65906   float arg2 ;
65907   Dali::Dimension::Type arg3 ;
65908   SwigDirector_ViewImpl *darg = 0;
65909
65910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65911   arg2 = (float)jarg2;
65912   arg3 = (Dali::Dimension::Type)jarg3;
65913   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65914   if (!darg) {
65915     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65916     return;
65917   }
65918   {
65919     try {
65920       (darg)->OnLayoutNegotiated(arg2,arg3);
65921     } catch (std::out_of_range& e) {
65922       {
65923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65924       };
65925     } catch (std::exception& e) {
65926       {
65927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65928       };
65929     } catch (Dali::DaliException e) {
65930       {
65931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65932       };
65933     } catch (...) {
65934       {
65935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65936       };
65937     }
65938   }
65939
65940 }
65941
65942
65943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65945   float arg2 ;
65946   Dali::Dimension::Type arg3 ;
65947   SwigDirector_ViewImpl *darg = 0;
65948
65949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65950   arg2 = (float)jarg2;
65951   arg3 = (Dali::Dimension::Type)jarg3;
65952   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65953   if (!darg) {
65954     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65955     return;
65956   }
65957   {
65958     try {
65959       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65960     } catch (std::out_of_range& e) {
65961       {
65962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65963       };
65964     } catch (std::exception& e) {
65965       {
65966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65967       };
65968     } catch (Dali::DaliException e) {
65969       {
65970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65971       };
65972     } catch (...) {
65973       {
65974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65975       };
65976     }
65977   }
65978
65979 }
65980
65981
65982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65984
65985   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65986   {
65987     try {
65988       (arg1)->OnInitialize();
65989     } catch (std::out_of_range& e) {
65990       {
65991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65992       };
65993     } catch (std::exception& e) {
65994       {
65995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65996       };
65997     } catch (Dali::DaliException e) {
65998       {
65999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66000       };
66001     } catch (...) {
66002       {
66003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66004       };
66005     }
66006   }
66007
66008 }
66009
66010
66011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66013
66014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66015   {
66016     try {
66017       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66018     } catch (std::out_of_range& e) {
66019       {
66020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66021       };
66022     } catch (std::exception& e) {
66023       {
66024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66025       };
66026     } catch (Dali::DaliException e) {
66027       {
66028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66029       };
66030     } catch (...) {
66031       {
66032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66033       };
66034     }
66035   }
66036
66037 }
66038
66039
66040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66041   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66042   Dali::Actor *arg2 = 0 ;
66043
66044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66045   arg2 = (Dali::Actor *)jarg2;
66046   if (!arg2) {
66047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66048     return ;
66049   }
66050   {
66051     try {
66052       (arg1)->OnControlChildAdd(*arg2);
66053     } catch (std::out_of_range& e) {
66054       {
66055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66056       };
66057     } catch (std::exception& e) {
66058       {
66059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66060       };
66061     } catch (Dali::DaliException e) {
66062       {
66063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66064       };
66065     } catch (...) {
66066       {
66067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66068       };
66069     }
66070   }
66071
66072 }
66073
66074
66075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66077   Dali::Actor *arg2 = 0 ;
66078
66079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66080   arg2 = (Dali::Actor *)jarg2;
66081   if (!arg2) {
66082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66083     return ;
66084   }
66085   {
66086     try {
66087       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66088     } catch (std::out_of_range& e) {
66089       {
66090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66091       };
66092     } catch (std::exception& e) {
66093       {
66094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66095       };
66096     } catch (Dali::DaliException e) {
66097       {
66098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66099       };
66100     } catch (...) {
66101       {
66102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66103       };
66104     }
66105   }
66106
66107 }
66108
66109
66110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66112   Dali::Actor *arg2 = 0 ;
66113
66114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66115   arg2 = (Dali::Actor *)jarg2;
66116   if (!arg2) {
66117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66118     return ;
66119   }
66120   {
66121     try {
66122       (arg1)->OnControlChildRemove(*arg2);
66123     } catch (std::out_of_range& e) {
66124       {
66125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66126       };
66127     } catch (std::exception& e) {
66128       {
66129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66130       };
66131     } catch (Dali::DaliException e) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66134       };
66135     } catch (...) {
66136       {
66137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66138       };
66139     }
66140   }
66141
66142 }
66143
66144
66145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66147   Dali::Actor *arg2 = 0 ;
66148
66149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66150   arg2 = (Dali::Actor *)jarg2;
66151   if (!arg2) {
66152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66153     return ;
66154   }
66155   {
66156     try {
66157       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66158     } catch (std::out_of_range& e) {
66159       {
66160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66161       };
66162     } catch (std::exception& e) {
66163       {
66164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66165       };
66166     } catch (Dali::DaliException e) {
66167       {
66168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66169       };
66170     } catch (...) {
66171       {
66172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66173       };
66174     }
66175   }
66176
66177 }
66178
66179
66180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66182   Dali::Toolkit::StyleManager arg2 ;
66183   Dali::StyleChange::Type arg3 ;
66184   Dali::Toolkit::StyleManager *argp2 ;
66185
66186   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66187   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66188   if (!argp2) {
66189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66190     return ;
66191   }
66192   arg2 = *argp2;
66193   arg3 = (Dali::StyleChange::Type)jarg3;
66194   {
66195     try {
66196       (arg1)->OnStyleChange(arg2,arg3);
66197     } catch (std::out_of_range& e) {
66198       {
66199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66200       };
66201     } catch (std::exception& e) {
66202       {
66203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66204       };
66205     } catch (Dali::DaliException e) {
66206       {
66207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66208       };
66209     } catch (...) {
66210       {
66211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66212       };
66213     }
66214   }
66215
66216 }
66217
66218
66219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66221   Dali::Toolkit::StyleManager arg2 ;
66222   Dali::StyleChange::Type arg3 ;
66223   Dali::Toolkit::StyleManager *argp2 ;
66224
66225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66226   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66227   if (!argp2) {
66228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66229     return ;
66230   }
66231   arg2 = *argp2;
66232   arg3 = (Dali::StyleChange::Type)jarg3;
66233   {
66234     try {
66235       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66236     } catch (std::out_of_range& e) {
66237       {
66238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66239       };
66240     } catch (std::exception& e) {
66241       {
66242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66243       };
66244     } catch (Dali::DaliException e) {
66245       {
66246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66247       };
66248     } catch (...) {
66249       {
66250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66251       };
66252     }
66253   }
66254
66255 }
66256
66257
66258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66259   unsigned int jresult ;
66260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66261   bool result;
66262
66263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66264   {
66265     try {
66266       result = (bool)(arg1)->OnAccessibilityActivated();
66267     } catch (std::out_of_range& e) {
66268       {
66269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66270       };
66271     } catch (std::exception& e) {
66272       {
66273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66274       };
66275     } catch (Dali::DaliException e) {
66276       {
66277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66278       };
66279     } catch (...) {
66280       {
66281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66282       };
66283     }
66284   }
66285
66286   jresult = result;
66287   return jresult;
66288 }
66289
66290
66291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66292   unsigned int jresult ;
66293   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66294   bool result;
66295
66296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66297   {
66298     try {
66299       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66300     } catch (std::out_of_range& e) {
66301       {
66302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66303       };
66304     } catch (std::exception& e) {
66305       {
66306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66307       };
66308     } catch (Dali::DaliException e) {
66309       {
66310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66311       };
66312     } catch (...) {
66313       {
66314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66315       };
66316     }
66317   }
66318
66319   jresult = result;
66320   return jresult;
66321 }
66322
66323
66324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66325   unsigned int jresult ;
66326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66327   Dali::PanGesture arg2 ;
66328   Dali::PanGesture *argp2 ;
66329   bool result;
66330
66331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66332   argp2 = (Dali::PanGesture *)jarg2;
66333   if (!argp2) {
66334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66335     return 0;
66336   }
66337   arg2 = *argp2;
66338   {
66339     try {
66340       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66341     } catch (std::out_of_range& e) {
66342       {
66343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66344       };
66345     } catch (std::exception& e) {
66346       {
66347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66348       };
66349     } catch (Dali::DaliException e) {
66350       {
66351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66352       };
66353     } catch (...) {
66354       {
66355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66356       };
66357     }
66358   }
66359
66360   jresult = result;
66361   return jresult;
66362 }
66363
66364
66365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66366   unsigned int jresult ;
66367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66368   Dali::PanGesture arg2 ;
66369   Dali::PanGesture *argp2 ;
66370   bool result;
66371
66372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66373   argp2 = (Dali::PanGesture *)jarg2;
66374   if (!argp2) {
66375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66376     return 0;
66377   }
66378   arg2 = *argp2;
66379   {
66380     try {
66381       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66382     } catch (std::out_of_range& e) {
66383       {
66384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66385       };
66386     } catch (std::exception& e) {
66387       {
66388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66389       };
66390     } catch (Dali::DaliException e) {
66391       {
66392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66393       };
66394     } catch (...) {
66395       {
66396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66397       };
66398     }
66399   }
66400
66401   jresult = result;
66402   return jresult;
66403 }
66404
66405
66406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66407   unsigned int jresult ;
66408   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66409   Dali::TouchEvent *arg2 = 0 ;
66410   bool result;
66411
66412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66413   arg2 = (Dali::TouchEvent *)jarg2;
66414   if (!arg2) {
66415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66416     return 0;
66417   }
66418   {
66419     try {
66420       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66421     } catch (std::out_of_range& e) {
66422       {
66423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66424       };
66425     } catch (std::exception& e) {
66426       {
66427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66428       };
66429     } catch (Dali::DaliException e) {
66430       {
66431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66432       };
66433     } catch (...) {
66434       {
66435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66436       };
66437     }
66438   }
66439
66440   jresult = result;
66441   return jresult;
66442 }
66443
66444
66445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66446   unsigned int jresult ;
66447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66448   Dali::TouchEvent *arg2 = 0 ;
66449   bool result;
66450
66451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66452   arg2 = (Dali::TouchEvent *)jarg2;
66453   if (!arg2) {
66454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66455     return 0;
66456   }
66457   {
66458     try {
66459       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66460     } catch (std::out_of_range& e) {
66461       {
66462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66463       };
66464     } catch (std::exception& e) {
66465       {
66466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66467       };
66468     } catch (Dali::DaliException e) {
66469       {
66470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66471       };
66472     } catch (...) {
66473       {
66474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66475       };
66476     }
66477   }
66478
66479   jresult = result;
66480   return jresult;
66481 }
66482
66483
66484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66485   unsigned int jresult ;
66486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66487   bool arg2 ;
66488   bool result;
66489
66490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66491   arg2 = jarg2 ? true : false;
66492   {
66493     try {
66494       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66495     } catch (std::out_of_range& e) {
66496       {
66497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66498       };
66499     } catch (std::exception& e) {
66500       {
66501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66502       };
66503     } catch (Dali::DaliException e) {
66504       {
66505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66506       };
66507     } catch (...) {
66508       {
66509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66510       };
66511     }
66512   }
66513
66514   jresult = result;
66515   return jresult;
66516 }
66517
66518
66519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66520   unsigned int jresult ;
66521   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66522   bool arg2 ;
66523   bool result;
66524
66525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66526   arg2 = jarg2 ? true : false;
66527   {
66528     try {
66529       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66530     } catch (std::out_of_range& e) {
66531       {
66532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66533       };
66534     } catch (std::exception& e) {
66535       {
66536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66537       };
66538     } catch (Dali::DaliException e) {
66539       {
66540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66541       };
66542     } catch (...) {
66543       {
66544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66545       };
66546     }
66547   }
66548
66549   jresult = result;
66550   return jresult;
66551 }
66552
66553
66554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66555   unsigned int jresult ;
66556   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66557   bool result;
66558
66559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66560   {
66561     try {
66562       result = (bool)(arg1)->OnAccessibilityZoom();
66563     } catch (std::out_of_range& e) {
66564       {
66565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66566       };
66567     } catch (std::exception& e) {
66568       {
66569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66570       };
66571     } catch (Dali::DaliException e) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66574       };
66575     } catch (...) {
66576       {
66577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66578       };
66579     }
66580   }
66581
66582   jresult = result;
66583   return jresult;
66584 }
66585
66586
66587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66588   unsigned int jresult ;
66589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66590   bool result;
66591
66592   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66593   {
66594     try {
66595       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66596     } catch (std::out_of_range& e) {
66597       {
66598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66599       };
66600     } catch (std::exception& e) {
66601       {
66602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66603       };
66604     } catch (Dali::DaliException e) {
66605       {
66606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66607       };
66608     } catch (...) {
66609       {
66610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66611       };
66612     }
66613   }
66614
66615   jresult = result;
66616   return jresult;
66617 }
66618
66619
66620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66622
66623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66624   {
66625     try {
66626       (arg1)->OnKeyInputFocusGained();
66627     } catch (std::out_of_range& e) {
66628       {
66629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66630       };
66631     } catch (std::exception& e) {
66632       {
66633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66634       };
66635     } catch (Dali::DaliException e) {
66636       {
66637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66638       };
66639     } catch (...) {
66640       {
66641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66642       };
66643     }
66644   }
66645
66646 }
66647
66648
66649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66650   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66651
66652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66653   {
66654     try {
66655       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66656     } catch (std::out_of_range& e) {
66657       {
66658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66659       };
66660     } catch (std::exception& e) {
66661       {
66662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66663       };
66664     } catch (Dali::DaliException e) {
66665       {
66666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66667       };
66668     } catch (...) {
66669       {
66670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66671       };
66672     }
66673   }
66674
66675 }
66676
66677
66678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66680
66681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66682   {
66683     try {
66684       (arg1)->OnKeyInputFocusLost();
66685     } catch (std::out_of_range& e) {
66686       {
66687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66688       };
66689     } catch (std::exception& e) {
66690       {
66691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66692       };
66693     } catch (Dali::DaliException e) {
66694       {
66695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66696       };
66697     } catch (...) {
66698       {
66699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66700       };
66701     }
66702   }
66703
66704 }
66705
66706
66707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66709
66710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66711   {
66712     try {
66713       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66721       };
66722     } catch (Dali::DaliException e) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66725       };
66726     } catch (...) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66729       };
66730     }
66731   }
66732
66733 }
66734
66735
66736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66737   void * jresult ;
66738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66739   Dali::Actor arg2 ;
66740   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66741   bool arg4 ;
66742   Dali::Actor *argp2 ;
66743   Dali::Actor result;
66744
66745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66746   argp2 = (Dali::Actor *)jarg2;
66747   if (!argp2) {
66748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66749     return 0;
66750   }
66751   arg2 = *argp2;
66752   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66753   arg4 = jarg4 ? true : false;
66754   {
66755     try {
66756       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66757     } catch (std::out_of_range& e) {
66758       {
66759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66760       };
66761     } catch (std::exception& e) {
66762       {
66763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66764       };
66765     } catch (Dali::DaliException e) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66768       };
66769     } catch (...) {
66770       {
66771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66772       };
66773     }
66774   }
66775
66776   jresult = new Dali::Actor((const Dali::Actor &)result);
66777   return jresult;
66778 }
66779
66780
66781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66782   void * jresult ;
66783   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66784   Dali::Actor arg2 ;
66785   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66786   bool arg4 ;
66787   Dali::Actor *argp2 ;
66788   Dali::Actor result;
66789
66790   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66791   argp2 = (Dali::Actor *)jarg2;
66792   if (!argp2) {
66793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66794     return 0;
66795   }
66796   arg2 = *argp2;
66797   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66798   arg4 = jarg4 ? true : false;
66799   {
66800     try {
66801       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66802     } catch (std::out_of_range& e) {
66803       {
66804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66805       };
66806     } catch (std::exception& e) {
66807       {
66808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66809       };
66810     } catch (Dali::DaliException e) {
66811       {
66812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66813       };
66814     } catch (...) {
66815       {
66816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66817       };
66818     }
66819   }
66820
66821   jresult = new Dali::Actor((const Dali::Actor &)result);
66822   return jresult;
66823 }
66824
66825
66826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66828   Dali::Actor arg2 ;
66829   Dali::Actor *argp2 ;
66830
66831   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66832   argp2 = (Dali::Actor *)jarg2;
66833   if (!argp2) {
66834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66835     return ;
66836   }
66837   arg2 = *argp2;
66838   {
66839     try {
66840       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66841     } catch (std::out_of_range& e) {
66842       {
66843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66844       };
66845     } catch (std::exception& e) {
66846       {
66847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66848       };
66849     } catch (Dali::DaliException e) {
66850       {
66851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66852       };
66853     } catch (...) {
66854       {
66855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66856       };
66857     }
66858   }
66859
66860 }
66861
66862
66863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66865   Dali::Actor arg2 ;
66866   Dali::Actor *argp2 ;
66867
66868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66869   argp2 = (Dali::Actor *)jarg2;
66870   if (!argp2) {
66871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66872     return ;
66873   }
66874   arg2 = *argp2;
66875   {
66876     try {
66877       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66878     } catch (std::out_of_range& e) {
66879       {
66880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66881       };
66882     } catch (std::exception& e) {
66883       {
66884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66885       };
66886     } catch (Dali::DaliException e) {
66887       {
66888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66889       };
66890     } catch (...) {
66891       {
66892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66893       };
66894     }
66895   }
66896
66897 }
66898
66899
66900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66901   unsigned int jresult ;
66902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66903   bool result;
66904
66905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66906   {
66907     try {
66908       result = (bool)(arg1)->OnKeyboardEnter();
66909     } catch (std::out_of_range& e) {
66910       {
66911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66912       };
66913     } catch (std::exception& e) {
66914       {
66915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66916       };
66917     } catch (Dali::DaliException e) {
66918       {
66919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66920       };
66921     } catch (...) {
66922       {
66923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66924       };
66925     }
66926   }
66927
66928   jresult = result;
66929   return jresult;
66930 }
66931
66932
66933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66934   unsigned int jresult ;
66935   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66936   bool result;
66937
66938   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66939   {
66940     try {
66941       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66942     } catch (std::out_of_range& e) {
66943       {
66944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66945       };
66946     } catch (std::exception& e) {
66947       {
66948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66949       };
66950     } catch (Dali::DaliException e) {
66951       {
66952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66953       };
66954     } catch (...) {
66955       {
66956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66957       };
66958     }
66959   }
66960
66961   jresult = result;
66962   return jresult;
66963 }
66964
66965
66966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66968   Dali::PinchGesture *arg2 = 0 ;
66969
66970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66971   arg2 = (Dali::PinchGesture *)jarg2;
66972   if (!arg2) {
66973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66974     return ;
66975   }
66976   {
66977     try {
66978       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66979     } catch (std::out_of_range& e) {
66980       {
66981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66982       };
66983     } catch (std::exception& e) {
66984       {
66985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66986       };
66987     } catch (Dali::DaliException e) {
66988       {
66989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66990       };
66991     } catch (...) {
66992       {
66993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66994       };
66995     }
66996   }
66997
66998 }
66999
67000
67001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67003   Dali::PinchGesture *arg2 = 0 ;
67004
67005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67006   arg2 = (Dali::PinchGesture *)jarg2;
67007   if (!arg2) {
67008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67009     return ;
67010   }
67011   {
67012     try {
67013       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67014     } catch (std::out_of_range& e) {
67015       {
67016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67017       };
67018     } catch (std::exception& e) {
67019       {
67020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67021       };
67022     } catch (Dali::DaliException e) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67025       };
67026     } catch (...) {
67027       {
67028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67029       };
67030     }
67031   }
67032
67033 }
67034
67035
67036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67038   Dali::PanGesture *arg2 = 0 ;
67039
67040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67041   arg2 = (Dali::PanGesture *)jarg2;
67042   if (!arg2) {
67043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67044     return ;
67045   }
67046   {
67047     try {
67048       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67049     } catch (std::out_of_range& e) {
67050       {
67051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67052       };
67053     } catch (std::exception& e) {
67054       {
67055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67056       };
67057     } catch (Dali::DaliException e) {
67058       {
67059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67060       };
67061     } catch (...) {
67062       {
67063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67064       };
67065     }
67066   }
67067
67068 }
67069
67070
67071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67073   Dali::PanGesture *arg2 = 0 ;
67074
67075   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67076   arg2 = (Dali::PanGesture *)jarg2;
67077   if (!arg2) {
67078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67079     return ;
67080   }
67081   {
67082     try {
67083       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67084     } catch (std::out_of_range& e) {
67085       {
67086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67087       };
67088     } catch (std::exception& e) {
67089       {
67090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67091       };
67092     } catch (Dali::DaliException e) {
67093       {
67094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67095       };
67096     } catch (...) {
67097       {
67098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67099       };
67100     }
67101   }
67102
67103 }
67104
67105
67106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67107   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67108   Dali::TapGesture *arg2 = 0 ;
67109
67110   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67111   arg2 = (Dali::TapGesture *)jarg2;
67112   if (!arg2) {
67113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67114     return ;
67115   }
67116   {
67117     try {
67118       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67119     } catch (std::out_of_range& e) {
67120       {
67121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67122       };
67123     } catch (std::exception& e) {
67124       {
67125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67126       };
67127     } catch (Dali::DaliException e) {
67128       {
67129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67130       };
67131     } catch (...) {
67132       {
67133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67134       };
67135     }
67136   }
67137
67138 }
67139
67140
67141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67143   Dali::TapGesture *arg2 = 0 ;
67144
67145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67146   arg2 = (Dali::TapGesture *)jarg2;
67147   if (!arg2) {
67148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67149     return ;
67150   }
67151   {
67152     try {
67153       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67154     } catch (std::out_of_range& e) {
67155       {
67156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67157       };
67158     } catch (std::exception& e) {
67159       {
67160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67161       };
67162     } catch (Dali::DaliException e) {
67163       {
67164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67165       };
67166     } catch (...) {
67167       {
67168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67169       };
67170     }
67171   }
67172
67173 }
67174
67175
67176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67177   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67178   Dali::LongPressGesture *arg2 = 0 ;
67179
67180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67181   arg2 = (Dali::LongPressGesture *)jarg2;
67182   if (!arg2) {
67183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67184     return ;
67185   }
67186   {
67187     try {
67188       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67189     } catch (std::out_of_range& e) {
67190       {
67191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67192       };
67193     } catch (std::exception& e) {
67194       {
67195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67196       };
67197     } catch (Dali::DaliException e) {
67198       {
67199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67200       };
67201     } catch (...) {
67202       {
67203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67204       };
67205     }
67206   }
67207
67208 }
67209
67210
67211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67213   Dali::LongPressGesture *arg2 = 0 ;
67214
67215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67216   arg2 = (Dali::LongPressGesture *)jarg2;
67217   if (!arg2) {
67218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67219     return ;
67220   }
67221   {
67222     try {
67223       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67224     } catch (std::out_of_range& e) {
67225       {
67226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67227       };
67228     } catch (std::exception& e) {
67229       {
67230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67231       };
67232     } catch (Dali::DaliException e) {
67233       {
67234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67235       };
67236     } catch (...) {
67237       {
67238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67239       };
67240     }
67241   }
67242
67243 }
67244
67245
67246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67248   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67249   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67250
67251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67252   arg2 = (Dali::SlotObserver *)jarg2;
67253   arg3 = (Dali::CallbackBase *)jarg3;
67254   {
67255     try {
67256       (arg1)->SignalConnected(arg2,arg3);
67257     } catch (std::out_of_range& e) {
67258       {
67259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67260       };
67261     } catch (std::exception& e) {
67262       {
67263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67264       };
67265     } catch (Dali::DaliException e) {
67266       {
67267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67268       };
67269     } catch (...) {
67270       {
67271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67272       };
67273     }
67274   }
67275
67276 }
67277
67278
67279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67281   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67282   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67283
67284   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67285   arg2 = (Dali::SlotObserver *)jarg2;
67286   arg3 = (Dali::CallbackBase *)jarg3;
67287   {
67288     try {
67289       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67290     } catch (std::out_of_range& e) {
67291       {
67292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67293       };
67294     } catch (std::exception& e) {
67295       {
67296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67297       };
67298     } catch (Dali::DaliException e) {
67299       {
67300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67301       };
67302     } catch (...) {
67303       {
67304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67305       };
67306     }
67307   }
67308
67309 }
67310
67311
67312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67314   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67315   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67316
67317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67318   arg2 = (Dali::SlotObserver *)jarg2;
67319   arg3 = (Dali::CallbackBase *)jarg3;
67320   {
67321     try {
67322       (arg1)->SignalDisconnected(arg2,arg3);
67323     } catch (std::out_of_range& e) {
67324       {
67325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67326       };
67327     } catch (std::exception& e) {
67328       {
67329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67330       };
67331     } catch (Dali::DaliException e) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67334       };
67335     } catch (...) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67338       };
67339     }
67340   }
67341
67342 }
67343
67344
67345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67347   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67348   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67349
67350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67351   arg2 = (Dali::SlotObserver *)jarg2;
67352   arg3 = (Dali::CallbackBase *)jarg3;
67353   {
67354     try {
67355       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67356     } catch (std::out_of_range& e) {
67357       {
67358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67359       };
67360     } catch (std::exception& e) {
67361       {
67362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67363       };
67364     } catch (Dali::DaliException e) {
67365       {
67366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67367       };
67368     } catch (...) {
67369       {
67370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67371       };
67372     }
67373   }
67374
67375 }
67376
67377
67378 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) {
67379   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67380   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67381   if (director) {
67382     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);
67383   }
67384 }
67385
67386
67387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67388   void * jresult ;
67389   Dali::Toolkit::Control *arg1 = 0 ;
67390   Dali::Toolkit::Internal::Control *result = 0 ;
67391
67392   arg1 = (Dali::Toolkit::Control *)jarg1;
67393   if (!arg1) {
67394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67395     return 0;
67396   }
67397   {
67398     try {
67399       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67400     } catch (std::out_of_range& e) {
67401       {
67402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67403       };
67404     } catch (std::exception& e) {
67405       {
67406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67407       };
67408     } catch (Dali::DaliException e) {
67409       {
67410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67411       };
67412     } catch (...) {
67413       {
67414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67415       };
67416     }
67417   }
67418
67419   jresult = (void *)result;
67420   return jresult;
67421 }
67422
67423
67424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67425   int jresult ;
67426   int result;
67427
67428   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67429   jresult = (int)result;
67430   return jresult;
67431 }
67432
67433
67434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67435   int jresult ;
67436   int result;
67437
67438   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67439   jresult = (int)result;
67440   return jresult;
67441 }
67442
67443
67444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67445   int jresult ;
67446   int result;
67447
67448   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67449   jresult = (int)result;
67450   return jresult;
67451 }
67452
67453
67454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67455   int jresult ;
67456   int result;
67457
67458   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67459   jresult = (int)result;
67460   return jresult;
67461 }
67462
67463
67464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67465   int jresult ;
67466   int result;
67467
67468   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67469   jresult = (int)result;
67470   return jresult;
67471 }
67472
67473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67474   int jresult ;
67475   int result;
67476
67477   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67478   jresult = (int)result;
67479   return jresult;
67480 }
67481
67482
67483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67484   int jresult ;
67485   int result;
67486
67487   result = (int)Dali::Toolkit::Control::Property::PADDING;
67488   jresult = (int)result;
67489   return jresult;
67490 }
67491
67492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67493   void * jresult ;
67494   Dali::Toolkit::Control::Property *result = 0 ;
67495
67496   {
67497     try {
67498       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67499     } catch (std::out_of_range& e) {
67500       {
67501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67502       };
67503     } catch (std::exception& e) {
67504       {
67505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67506       };
67507     } catch (Dali::DaliException e) {
67508       {
67509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67510       };
67511     } catch (...) {
67512       {
67513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67514       };
67515     }
67516   }
67517
67518   jresult = (void *)result;
67519   return jresult;
67520 }
67521
67522
67523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67524   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67525
67526   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67527   {
67528     try {
67529       delete arg1;
67530     } catch (std::out_of_range& e) {
67531       {
67532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67533       };
67534     } catch (std::exception& e) {
67535       {
67536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67537       };
67538     } catch (Dali::DaliException e) {
67539       {
67540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67541       };
67542     } catch (...) {
67543       {
67544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67545       };
67546     }
67547   }
67548
67549 }
67550
67551
67552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67553   void * jresult ;
67554   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67555
67556   {
67557     try {
67558       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67559     } catch (std::out_of_range& e) {
67560       {
67561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67562       };
67563     } catch (std::exception& e) {
67564       {
67565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67566       };
67567     } catch (Dali::DaliException e) {
67568       {
67569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67570       };
67571     } catch (...) {
67572       {
67573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67574       };
67575     }
67576   }
67577
67578   jresult = (void *)result;
67579   return jresult;
67580 }
67581
67582
67583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67584   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67585
67586   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67587   {
67588     try {
67589       delete arg1;
67590     } catch (std::out_of_range& e) {
67591       {
67592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67593       };
67594     } catch (std::exception& e) {
67595       {
67596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67597       };
67598     } catch (Dali::DaliException e) {
67599       {
67600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67601       };
67602     } catch (...) {
67603       {
67604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67605       };
67606     }
67607   }
67608
67609 }
67610
67611
67612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67613   void * jresult ;
67614   Dali::Toolkit::Control result;
67615
67616   {
67617     try {
67618       result = Dali::Toolkit::Control::New();
67619     } catch (std::out_of_range& e) {
67620       {
67621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67622       };
67623     } catch (std::exception& e) {
67624       {
67625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67626       };
67627     } catch (Dali::DaliException e) {
67628       {
67629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67630       };
67631     } catch (...) {
67632       {
67633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67634       };
67635     }
67636   }
67637
67638   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67639   return jresult;
67640 }
67641
67642
67643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67644   void * jresult ;
67645   Dali::Toolkit::Control *result = 0 ;
67646
67647   {
67648     try {
67649       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67650     } catch (std::out_of_range& e) {
67651       {
67652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67653       };
67654     } catch (std::exception& e) {
67655       {
67656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67657       };
67658     } catch (Dali::DaliException e) {
67659       {
67660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67661       };
67662     } catch (...) {
67663       {
67664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67665       };
67666     }
67667   }
67668
67669   jresult = (void *)result;
67670   return jresult;
67671 }
67672
67673
67674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67675   void * jresult ;
67676   Dali::Toolkit::Control *arg1 = 0 ;
67677   Dali::Toolkit::Control *result = 0 ;
67678
67679   arg1 = (Dali::Toolkit::Control *)jarg1;
67680   if (!arg1) {
67681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67682     return 0;
67683   }
67684   {
67685     try {
67686       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67687     } catch (std::out_of_range& e) {
67688       {
67689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67690       };
67691     } catch (std::exception& e) {
67692       {
67693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67694       };
67695     } catch (Dali::DaliException e) {
67696       {
67697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67698       };
67699     } catch (...) {
67700       {
67701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67702       };
67703     }
67704   }
67705
67706   jresult = (void *)result;
67707   return jresult;
67708 }
67709
67710
67711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67712   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67713
67714   arg1 = (Dali::Toolkit::Control *)jarg1;
67715   {
67716     try {
67717       delete arg1;
67718     } catch (std::out_of_range& e) {
67719       {
67720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67721       };
67722     } catch (std::exception& e) {
67723       {
67724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67725       };
67726     } catch (Dali::DaliException e) {
67727       {
67728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67729       };
67730     } catch (...) {
67731       {
67732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67733       };
67734     }
67735   }
67736
67737 }
67738
67739
67740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67741   void * jresult ;
67742   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67743   Dali::Toolkit::Control *arg2 = 0 ;
67744   Dali::Toolkit::Control *result = 0 ;
67745
67746   arg1 = (Dali::Toolkit::Control *)jarg1;
67747   arg2 = (Dali::Toolkit::Control *)jarg2;
67748   if (!arg2) {
67749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67750     return 0;
67751   }
67752   {
67753     try {
67754       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67755     } catch (std::out_of_range& e) {
67756       {
67757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67758       };
67759     } catch (std::exception& e) {
67760       {
67761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67762       };
67763     } catch (Dali::DaliException e) {
67764       {
67765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67766       };
67767     } catch (...) {
67768       {
67769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67770       };
67771     }
67772   }
67773
67774   jresult = (void *)result;
67775   return jresult;
67776 }
67777
67778
67779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67780   void * jresult ;
67781   Dali::BaseHandle arg1 ;
67782   Dali::BaseHandle *argp1 ;
67783   Dali::Toolkit::Control result;
67784
67785   argp1 = (Dali::BaseHandle *)jarg1;
67786   if (!argp1) {
67787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67788     return 0;
67789   }
67790   arg1 = *argp1;
67791   {
67792     try {
67793       result = Dali::Toolkit::Control::DownCast(arg1);
67794     } catch (std::out_of_range& e) {
67795       {
67796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67797       };
67798     } catch (std::exception& e) {
67799       {
67800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67801       };
67802     } catch (Dali::DaliException e) {
67803       {
67804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67805       };
67806     } catch (...) {
67807       {
67808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67809       };
67810     }
67811   }
67812
67813   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67814   return jresult;
67815 }
67816
67817
67818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67819   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67820
67821   arg1 = (Dali::Toolkit::Control *)jarg1;
67822   {
67823     try {
67824       (arg1)->SetKeyInputFocus();
67825     } catch (std::out_of_range& e) {
67826       {
67827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67828       };
67829     } catch (std::exception& e) {
67830       {
67831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67832       };
67833     } catch (Dali::DaliException e) {
67834       {
67835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67836       };
67837     } catch (...) {
67838       {
67839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67840       };
67841     }
67842   }
67843
67844 }
67845
67846
67847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67848   unsigned int jresult ;
67849   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67850   bool result;
67851
67852   arg1 = (Dali::Toolkit::Control *)jarg1;
67853   {
67854     try {
67855       result = (bool)(arg1)->HasKeyInputFocus();
67856     } catch (std::out_of_range& e) {
67857       {
67858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67859       };
67860     } catch (std::exception& e) {
67861       {
67862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67863       };
67864     } catch (Dali::DaliException e) {
67865       {
67866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67867       };
67868     } catch (...) {
67869       {
67870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67871       };
67872     }
67873   }
67874
67875   jresult = result;
67876   return jresult;
67877 }
67878
67879
67880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67881   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67882
67883   arg1 = (Dali::Toolkit::Control *)jarg1;
67884   {
67885     try {
67886       (arg1)->ClearKeyInputFocus();
67887     } catch (std::out_of_range& e) {
67888       {
67889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67890       };
67891     } catch (std::exception& e) {
67892       {
67893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67894       };
67895     } catch (Dali::DaliException e) {
67896       {
67897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67898       };
67899     } catch (...) {
67900       {
67901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67902       };
67903     }
67904   }
67905
67906 }
67907
67908
67909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67910   void * jresult ;
67911   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67912   Dali::PinchGestureDetector result;
67913
67914   arg1 = (Dali::Toolkit::Control *)jarg1;
67915   {
67916     try {
67917       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67918     } catch (std::out_of_range& e) {
67919       {
67920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67921       };
67922     } catch (std::exception& e) {
67923       {
67924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (Dali::DaliException e) {
67927       {
67928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67929       };
67930     } catch (...) {
67931       {
67932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67933       };
67934     }
67935   }
67936
67937   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67938   return jresult;
67939 }
67940
67941
67942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67943   void * jresult ;
67944   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67945   Dali::PanGestureDetector result;
67946
67947   arg1 = (Dali::Toolkit::Control *)jarg1;
67948   {
67949     try {
67950       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67951     } catch (std::out_of_range& e) {
67952       {
67953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67954       };
67955     } catch (std::exception& e) {
67956       {
67957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67958       };
67959     } catch (Dali::DaliException e) {
67960       {
67961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67962       };
67963     } catch (...) {
67964       {
67965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67966       };
67967     }
67968   }
67969
67970   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67971   return jresult;
67972 }
67973
67974
67975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67976   void * jresult ;
67977   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67978   Dali::TapGestureDetector result;
67979
67980   arg1 = (Dali::Toolkit::Control *)jarg1;
67981   {
67982     try {
67983       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67984     } catch (std::out_of_range& e) {
67985       {
67986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67987       };
67988     } catch (std::exception& e) {
67989       {
67990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67991       };
67992     } catch (Dali::DaliException e) {
67993       {
67994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67995       };
67996     } catch (...) {
67997       {
67998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67999       };
68000     }
68001   }
68002
68003   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68004   return jresult;
68005 }
68006
68007
68008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68009   void * jresult ;
68010   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68011   Dali::LongPressGestureDetector result;
68012
68013   arg1 = (Dali::Toolkit::Control *)jarg1;
68014   {
68015     try {
68016       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68017     } catch (std::out_of_range& e) {
68018       {
68019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68020       };
68021     } catch (std::exception& e) {
68022       {
68023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68024       };
68025     } catch (Dali::DaliException e) {
68026       {
68027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68028       };
68029     } catch (...) {
68030       {
68031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68032       };
68033     }
68034   }
68035
68036   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68037   return jresult;
68038 }
68039
68040
68041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68042   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68043   std::string *arg2 = 0 ;
68044
68045   arg1 = (Dali::Toolkit::Control *)jarg1;
68046   if (!jarg2) {
68047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68048     return ;
68049   }
68050   std::string arg2_str(jarg2);
68051   arg2 = &arg2_str;
68052   {
68053     try {
68054       (arg1)->SetStyleName((std::string const &)*arg2);
68055     } catch (std::out_of_range& e) {
68056       {
68057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68058       };
68059     } catch (std::exception& e) {
68060       {
68061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68062       };
68063     } catch (Dali::DaliException e) {
68064       {
68065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68066       };
68067     } catch (...) {
68068       {
68069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68070       };
68071     }
68072   }
68073
68074
68075   //argout typemap for const std::string&
68076
68077 }
68078
68079
68080 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68081   char * jresult ;
68082   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68083   std::string *result = 0 ;
68084
68085   arg1 = (Dali::Toolkit::Control *)jarg1;
68086   {
68087     try {
68088       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68089     } catch (std::out_of_range& e) {
68090       {
68091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68092       };
68093     } catch (std::exception& e) {
68094       {
68095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68096       };
68097     } catch (Dali::DaliException e) {
68098       {
68099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68100       };
68101     } catch (...) {
68102       {
68103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68104       };
68105     }
68106   }
68107
68108   jresult = SWIG_csharp_string_callback(result->c_str());
68109   return jresult;
68110 }
68111
68112
68113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68114   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68115   Dali::Vector4 *arg2 = 0 ;
68116
68117   arg1 = (Dali::Toolkit::Control *)jarg1;
68118   arg2 = (Dali::Vector4 *)jarg2;
68119   if (!arg2) {
68120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68121     return ;
68122   }
68123   {
68124     try {
68125       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68126     } catch (std::out_of_range& e) {
68127       {
68128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68129       };
68130     } catch (std::exception& e) {
68131       {
68132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68133       };
68134     } catch (Dali::DaliException e) {
68135       {
68136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68137       };
68138     } catch (...) {
68139       {
68140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68141       };
68142     }
68143   }
68144
68145 }
68146
68147
68148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68149   void * jresult ;
68150   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68151   Dali::Vector4 result;
68152
68153   arg1 = (Dali::Toolkit::Control *)jarg1;
68154   {
68155     try {
68156       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68157     } catch (std::out_of_range& e) {
68158       {
68159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68160       };
68161     } catch (std::exception& e) {
68162       {
68163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68164       };
68165     } catch (Dali::DaliException e) {
68166       {
68167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68172       };
68173     }
68174   }
68175
68176   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68177   return jresult;
68178 }
68179
68180
68181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68182   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68183   Dali::Image arg2 ;
68184   Dali::Image *argp2 ;
68185
68186   arg1 = (Dali::Toolkit::Control *)jarg1;
68187   argp2 = (Dali::Image *)jarg2;
68188   if (!argp2) {
68189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68190     return ;
68191   }
68192   arg2 = *argp2;
68193   {
68194     try {
68195       (arg1)->SetBackgroundImage(arg2);
68196     } catch (std::out_of_range& e) {
68197       {
68198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68199       };
68200     } catch (std::exception& e) {
68201       {
68202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68203       };
68204     } catch (Dali::DaliException e) {
68205       {
68206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68207       };
68208     } catch (...) {
68209       {
68210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68211       };
68212     }
68213   }
68214
68215 }
68216
68217
68218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68219   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68220
68221   arg1 = (Dali::Toolkit::Control *)jarg1;
68222   {
68223     try {
68224       (arg1)->ClearBackground();
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 (Dali::DaliException e) {
68234       {
68235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68236       };
68237     } catch (...) {
68238       {
68239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68240       };
68241     }
68242   }
68243
68244 }
68245
68246
68247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68248   void * jresult ;
68249   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68250   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68251
68252   arg1 = (Dali::Toolkit::Control *)jarg1;
68253   {
68254     try {
68255       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
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 (Dali::DaliException e) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68267       };
68268     } catch (...) {
68269       {
68270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68271       };
68272     }
68273   }
68274
68275   jresult = (void *)result;
68276   return jresult;
68277 }
68278
68279
68280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68281   void * jresult ;
68282   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68283   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68284
68285   arg1 = (Dali::Toolkit::Control *)jarg1;
68286   {
68287     try {
68288       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68289     } catch (std::out_of_range& e) {
68290       {
68291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68292       };
68293     } catch (std::exception& e) {
68294       {
68295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68296       };
68297     } catch (Dali::DaliException e) {
68298       {
68299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68300       };
68301     } catch (...) {
68302       {
68303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68304       };
68305     }
68306   }
68307
68308   jresult = (void *)result;
68309   return jresult;
68310 }
68311
68312
68313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68314   void * jresult ;
68315   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68316   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68317
68318   arg1 = (Dali::Toolkit::Control *)jarg1;
68319   {
68320     try {
68321       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68322     } catch (std::out_of_range& e) {
68323       {
68324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68325       };
68326     } catch (std::exception& e) {
68327       {
68328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68329       };
68330     } catch (Dali::DaliException e) {
68331       {
68332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68333       };
68334     } catch (...) {
68335       {
68336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68337       };
68338     }
68339   }
68340
68341   jresult = (void *)result;
68342   return jresult;
68343 }
68344
68345
68346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68347   void * jresult ;
68348   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68349   Dali::Toolkit::Control *result = 0 ;
68350
68351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68352   if (!arg1) {
68353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68354     return 0;
68355   }
68356   {
68357     try {
68358       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68359     } catch (std::out_of_range& e) {
68360       {
68361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68362       };
68363     } catch (std::exception& e) {
68364       {
68365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68366       };
68367     } catch (Dali::DaliException e) {
68368       {
68369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68370       };
68371     } catch (...) {
68372       {
68373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68374       };
68375     }
68376   }
68377
68378   jresult = (void *)result;
68379   return jresult;
68380 }
68381
68382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68383 {
68384   int jresult;
68385   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68386   arg1 = (Dali::Toolkit::Control *)jarg1;
68387
68388   if (!arg1) {
68389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68390     return 0;
68391   }
68392
68393   Dali::Property::Index arg2 = 0 ;
68394   arg2 = (Dali::Property::Index)jarg2;
68395
68396   Toolkit::Visual::ResourceStatus result;
68397   {
68398     try {
68399       result = arg1->GetVisualResourceStatus(arg2);
68400     } catch (std::out_of_range& e) {
68401       {
68402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68403       };
68404     } catch (std::exception& e) {
68405       {
68406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68407       };
68408     } catch (...) {
68409       {
68410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68411       };
68412     }
68413   }
68414   jresult = (int)(result);
68415   return jresult;
68416 }
68417
68418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68419 {
68420   void * jresult;
68421   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68422   arg1 = (Dali::Toolkit::Control *)jarg1;
68423
68424   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68425
68426   Dali::Toolkit::TransitionData *arg2 = 0 ;
68427   Dali::Animation result;
68428
68429   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68430   if (!arg2) {
68431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68432     return 0;
68433   }
68434   {
68435     try {
68436       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68437     } catch (std::out_of_range& e) {
68438       {
68439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68440       };
68441     } catch (std::exception& e) {
68442       {
68443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68444       };
68445     } catch (Dali::DaliException e) {
68446       {
68447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68448       };
68449     } catch (...) {
68450       {
68451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68452       };
68453     }
68454   }
68455
68456   jresult = new Dali::Animation((const Dali::Animation &)result);
68457   return jresult;
68458 }
68459
68460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68461 {
68462   Dali::Toolkit::Control arg1;
68463   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68464
68465   if (!argp1) {
68466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68467   }
68468   arg1 = *argp1;
68469
68470   Dali::Property::Index arg2 = 0 ;
68471   arg2 = (Dali::Property::Index)jarg2;
68472
68473   Dali::Property::Index arg3 = 0 ;
68474   arg3 = (Dali::Property::Index)jarg3;
68475
68476   Dali::Property::Value arg4;
68477   arg4 = (Dali::Property::Value *)jarg4;
68478
68479   {
68480     try {
68481       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68482     } catch (std::out_of_range& e) {
68483       {
68484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68485       };
68486     } catch (std::exception& e) {
68487       {
68488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68489       };
68490     } catch (...) {
68491       {
68492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68493       };
68494     }
68495   }
68496
68497
68498 }
68499
68500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68501   void * jresult ;
68502   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68503   Dali::Toolkit::LayoutItem result;
68504
68505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68506   if (!arg1) {
68507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68508     return 0;
68509   }
68510   {
68511     try {
68512       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68513     } catch (std::out_of_range& e) {
68514       {
68515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68516       };
68517     } catch (std::exception& e) {
68518       {
68519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68520       };
68521     } catch (...) {
68522       {
68523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68524       };
68525     }
68526   }
68527   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68528   return jresult;
68529 }
68530
68531
68532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68533   void * jresult ;
68534   Dali::Toolkit::Control arg1 ;
68535   Dali::Toolkit::Control *argp1 ;
68536   Dali::Toolkit::LayoutItem result;
68537
68538   argp1 = (Dali::Toolkit::Control *)jarg1;
68539   if (!argp1) {
68540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68541     return 0;
68542   }
68543   arg1 = *argp1;
68544   {
68545     try {
68546       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68547     } catch (std::out_of_range& e) {
68548       {
68549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68550       };
68551     } catch (std::exception& e) {
68552       {
68553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68554       };
68555     } catch (...) {
68556       {
68557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68558       };
68559     }
68560   }
68561   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68562   return jresult;
68563 }
68564
68565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68566   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68567   Dali::Toolkit::LayoutItem arg2 ;
68568   Dali::Toolkit::LayoutItem *argp2 ;
68569
68570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68571   if (!arg1) {
68572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68573     return ;
68574   }
68575   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68576   if (!argp2) {
68577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68578     return ;
68579   }
68580   arg2 = *argp2;
68581   {
68582     try {
68583       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68584     } catch (std::out_of_range& e) {
68585       {
68586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68587       };
68588     } catch (std::exception& e) {
68589       {
68590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68591       };
68592     } catch (...) {
68593       {
68594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68595       };
68596     }
68597   }
68598 }
68599
68600
68601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68602   Dali::Toolkit::Control arg1 ;
68603   Dali::Toolkit::LayoutItem arg2 ;
68604   Dali::Toolkit::Control *argp1 ;
68605   Dali::Toolkit::LayoutItem *argp2 ;
68606
68607   argp1 = (Dali::Toolkit::Control *)jarg1;
68608   if (!argp1) {
68609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68610     return ;
68611   }
68612   arg1 = *argp1;
68613   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68614   if (!argp2) {
68615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68616     return ;
68617   }
68618   arg2 = *argp2;
68619   {
68620     try {
68621       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68622     } catch (std::out_of_range& e) {
68623       {
68624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68625       };
68626     } catch (std::exception& e) {
68627       {
68628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68629       };
68630     } catch (...) {
68631       {
68632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68633       };
68634     }
68635   }
68636 }
68637
68638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayoutingRequired(void * jarg1, bool jarg2) {
68639   Dali::Toolkit::Control *arg1 = 0 ;
68640
68641   arg1 = (Dali::Toolkit::Control *)jarg1;
68642   if (!arg1) {
68643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68644     return ;
68645   }
68646
68647   {
68648     try {
68649       Dali::Toolkit::DevelControl::SetLayoutingRequired(*arg1,jarg2);
68650     } catch (std::out_of_range& e) {
68651       {
68652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68653       };
68654     } catch (std::exception& e) {
68655       {
68656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68657       };
68658     } catch (...) {
68659       {
68660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68661       };
68662     }
68663   }
68664 }
68665
68666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_IsLayoutingRequired(void * jarg1) {
68667   unsigned int jresult ;
68668   Dali::Toolkit::Control *arg1 = 0 ;
68669   bool result;
68670
68671   arg1 = (Dali::Toolkit::Control *)jarg1;
68672   if (!arg1) {
68673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68674     return 0;
68675   }
68676   {
68677     try {
68678       result = (bool)DevelControl::IsLayoutingRequired( *arg1 );
68679     } catch (std::out_of_range& e) {
68680       {
68681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68682       };
68683     } catch (std::exception& e) {
68684       {
68685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68686       };
68687     } catch (Dali::DaliException e) {
68688       {
68689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68690       };
68691     } catch (...) {
68692       {
68693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68694       };
68695     }
68696   }
68697
68698   jresult = result;
68699   return jresult;
68700 }
68701
68702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68703   void * jresult ;
68704   Dali::Toolkit::Control *arg1 = 0 ;
68705   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68706
68707   arg1 = (Dali::Toolkit::Control *)jarg1;
68708   if (!arg1) {
68709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68710     return 0;
68711   }
68712   {
68713     try {
68714       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68715     } catch (std::out_of_range& e) {
68716       {
68717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68718       };
68719     } catch (std::exception& e) {
68720       {
68721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68722       };
68723     } catch (Dali::DaliException e) {
68724       {
68725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68726       };
68727     } catch (...) {
68728       {
68729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68730       };
68731     }
68732   }
68733
68734   jresult = (void *)result;
68735   return jresult;
68736 }
68737
68738
68739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68740   unsigned int jresult ;
68741   Dali::Toolkit::Control *arg1 = 0 ;
68742   bool result;
68743
68744   arg1 = (Dali::Toolkit::Control *)jarg1;
68745   if (!arg1) {
68746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68747     return 0;
68748   }
68749   {
68750     try {
68751       result = (bool)arg1->IsResourceReady();
68752     } catch (std::out_of_range& e) {
68753       {
68754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68755       };
68756     } catch (std::exception& e) {
68757       {
68758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68759       };
68760     } catch (Dali::DaliException e) {
68761       {
68762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68763       };
68764     } catch (...) {
68765       {
68766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68767       };
68768     }
68769   }
68770
68771   jresult = result;
68772   return jresult;
68773 }
68774
68775
68776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68777   void * jresult ;
68778   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68779
68780   {
68781     try {
68782       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68783     } catch (std::out_of_range& e) {
68784       {
68785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68786       };
68787     } catch (std::exception& e) {
68788       {
68789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68790       };
68791     } catch (Dali::DaliException e) {
68792       {
68793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68794       };
68795     } catch (...) {
68796       {
68797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68798       };
68799     }
68800   }
68801
68802   jresult = (void *)result;
68803   return jresult;
68804 }
68805
68806
68807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68808   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68809
68810   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68811   {
68812     try {
68813       delete arg1;
68814     } catch (std::out_of_range& e) {
68815       {
68816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68817       };
68818     } catch (std::exception& e) {
68819       {
68820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68821       };
68822     } catch (Dali::DaliException e) {
68823       {
68824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68825       };
68826     } catch (...) {
68827       {
68828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68829       };
68830     }
68831   }
68832
68833 }
68834
68835
68836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68837   void * jresult ;
68838   Dali::Toolkit::KeyInputFocusManager result;
68839
68840   {
68841     try {
68842       result = Dali::Toolkit::KeyInputFocusManager::Get();
68843     } catch (std::out_of_range& e) {
68844       {
68845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68846       };
68847     } catch (std::exception& e) {
68848       {
68849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68850       };
68851     } catch (Dali::DaliException e) {
68852       {
68853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68854       };
68855     } catch (...) {
68856       {
68857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68858       };
68859     }
68860   }
68861
68862   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68863   return jresult;
68864 }
68865
68866
68867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68868   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68869   Dali::Toolkit::Control arg2 ;
68870   Dali::Toolkit::Control *argp2 ;
68871
68872   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68873   argp2 = (Dali::Toolkit::Control *)jarg2;
68874   if (!argp2) {
68875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68876     return ;
68877   }
68878   arg2 = *argp2;
68879   {
68880     try {
68881       (arg1)->SetFocus(arg2);
68882     } catch (std::out_of_range& e) {
68883       {
68884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68885       };
68886     } catch (std::exception& e) {
68887       {
68888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68889       };
68890     } catch (Dali::DaliException e) {
68891       {
68892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68893       };
68894     } catch (...) {
68895       {
68896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68897       };
68898     }
68899   }
68900
68901 }
68902
68903
68904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68905   void * jresult ;
68906   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68907   Dali::Toolkit::Control result;
68908
68909   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68910   {
68911     try {
68912       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68913     } catch (std::out_of_range& e) {
68914       {
68915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68916       };
68917     } catch (std::exception& e) {
68918       {
68919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68920       };
68921     } catch (Dali::DaliException e) {
68922       {
68923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68924       };
68925     } catch (...) {
68926       {
68927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68928       };
68929     }
68930   }
68931
68932   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68933   return jresult;
68934 }
68935
68936
68937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68938   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68939   Dali::Toolkit::Control arg2 ;
68940   Dali::Toolkit::Control *argp2 ;
68941
68942   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68943   argp2 = (Dali::Toolkit::Control *)jarg2;
68944   if (!argp2) {
68945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68946     return ;
68947   }
68948   arg2 = *argp2;
68949   {
68950     try {
68951       (arg1)->RemoveFocus(arg2);
68952     } catch (std::out_of_range& e) {
68953       {
68954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68955       };
68956     } catch (std::exception& e) {
68957       {
68958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68959       };
68960     } catch (Dali::DaliException e) {
68961       {
68962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68963       };
68964     } catch (...) {
68965       {
68966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68967       };
68968     }
68969   }
68970
68971 }
68972
68973
68974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68975   void * jresult ;
68976   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68977   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68978
68979   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68980   {
68981     try {
68982       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68983     } catch (std::out_of_range& e) {
68984       {
68985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68986       };
68987     } catch (std::exception& e) {
68988       {
68989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68990       };
68991     } catch (Dali::DaliException e) {
68992       {
68993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68994       };
68995     } catch (...) {
68996       {
68997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68998       };
68999     }
69000   }
69001
69002   jresult = (void *)result;
69003   return jresult;
69004 }
69005
69006
69007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69008   void * jresult ;
69009   Dali::Toolkit::Alignment::Padding *result = 0 ;
69010
69011   {
69012     try {
69013       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69014     } catch (std::out_of_range& e) {
69015       {
69016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69017       };
69018     } catch (std::exception& e) {
69019       {
69020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69021       };
69022     } catch (Dali::DaliException e) {
69023       {
69024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69025       };
69026     } catch (...) {
69027       {
69028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69029       };
69030     }
69031   }
69032
69033   jresult = (void *)result;
69034   return jresult;
69035 }
69036
69037
69038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69039   void * jresult ;
69040   float arg1 ;
69041   float arg2 ;
69042   float arg3 ;
69043   float arg4 ;
69044   Dali::Toolkit::Alignment::Padding *result = 0 ;
69045
69046   arg1 = (float)jarg1;
69047   arg2 = (float)jarg2;
69048   arg3 = (float)jarg3;
69049   arg4 = (float)jarg4;
69050   {
69051     try {
69052       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69053     } catch (std::out_of_range& e) {
69054       {
69055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69056       };
69057     } catch (std::exception& e) {
69058       {
69059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69060       };
69061     } catch (Dali::DaliException e) {
69062       {
69063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69064       };
69065     } catch (...) {
69066       {
69067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69068       };
69069     }
69070   }
69071
69072   jresult = (void *)result;
69073   return jresult;
69074 }
69075
69076
69077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69078   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69079   float arg2 ;
69080
69081   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69082   arg2 = (float)jarg2;
69083   if (arg1) (arg1)->left = arg2;
69084 }
69085
69086
69087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69088   float jresult ;
69089   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69090   float result;
69091
69092   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69093   result = (float) ((arg1)->left);
69094   jresult = result;
69095   return jresult;
69096 }
69097
69098
69099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69100   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69101   float arg2 ;
69102
69103   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69104   arg2 = (float)jarg2;
69105   if (arg1) (arg1)->right = arg2;
69106 }
69107
69108
69109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69110   float jresult ;
69111   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69112   float result;
69113
69114   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69115   result = (float) ((arg1)->right);
69116   jresult = result;
69117   return jresult;
69118 }
69119
69120
69121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69122   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69123   float arg2 ;
69124
69125   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69126   arg2 = (float)jarg2;
69127   if (arg1) (arg1)->top = arg2;
69128 }
69129
69130
69131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69132   float jresult ;
69133   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69134   float result;
69135
69136   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69137   result = (float) ((arg1)->top);
69138   jresult = result;
69139   return jresult;
69140 }
69141
69142
69143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69144   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69145   float arg2 ;
69146
69147   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69148   arg2 = (float)jarg2;
69149   if (arg1) (arg1)->bottom = arg2;
69150 }
69151
69152
69153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69154   float jresult ;
69155   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69156   float result;
69157
69158   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69159   result = (float) ((arg1)->bottom);
69160   jresult = result;
69161   return jresult;
69162 }
69163
69164
69165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69166   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69167
69168   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69169   {
69170     try {
69171       delete arg1;
69172     } catch (std::out_of_range& e) {
69173       {
69174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69175       };
69176     } catch (std::exception& e) {
69177       {
69178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69179       };
69180     } catch (Dali::DaliException e) {
69181       {
69182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69183       };
69184     } catch (...) {
69185       {
69186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69187       };
69188     }
69189   }
69190
69191 }
69192
69193
69194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69195   void * jresult ;
69196   Dali::Toolkit::Alignment *result = 0 ;
69197
69198   {
69199     try {
69200       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69201     } catch (std::out_of_range& e) {
69202       {
69203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69204       };
69205     } catch (std::exception& e) {
69206       {
69207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69208       };
69209     } catch (Dali::DaliException e) {
69210       {
69211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69212       };
69213     } catch (...) {
69214       {
69215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69216       };
69217     }
69218   }
69219
69220   jresult = (void *)result;
69221   return jresult;
69222 }
69223
69224
69225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69226   void * jresult ;
69227   Dali::Toolkit::Alignment::Type arg1 ;
69228   Dali::Toolkit::Alignment::Type arg2 ;
69229   Dali::Toolkit::Alignment result;
69230
69231   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69232   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69233   {
69234     try {
69235       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69236     } catch (std::out_of_range& e) {
69237       {
69238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69239       };
69240     } catch (std::exception& e) {
69241       {
69242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (Dali::DaliException e) {
69245       {
69246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69247       };
69248     } catch (...) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69251       };
69252     }
69253   }
69254
69255   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69256   return jresult;
69257 }
69258
69259
69260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69261   void * jresult ;
69262   Dali::Toolkit::Alignment::Type arg1 ;
69263   Dali::Toolkit::Alignment result;
69264
69265   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69266   {
69267     try {
69268       result = Dali::Toolkit::Alignment::New(arg1);
69269     } catch (std::out_of_range& e) {
69270       {
69271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69272       };
69273     } catch (std::exception& e) {
69274       {
69275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69276       };
69277     } catch (Dali::DaliException e) {
69278       {
69279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69280       };
69281     } catch (...) {
69282       {
69283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69284       };
69285     }
69286   }
69287
69288   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69289   return jresult;
69290 }
69291
69292
69293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69294   void * jresult ;
69295   Dali::Toolkit::Alignment result;
69296
69297   {
69298     try {
69299       result = Dali::Toolkit::Alignment::New();
69300     } catch (std::out_of_range& e) {
69301       {
69302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69303       };
69304     } catch (std::exception& e) {
69305       {
69306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (Dali::DaliException e) {
69309       {
69310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69311       };
69312     } catch (...) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69315       };
69316     }
69317   }
69318
69319   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69320   return jresult;
69321 }
69322
69323
69324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69325   void * jresult ;
69326   Dali::Toolkit::Alignment *arg1 = 0 ;
69327   Dali::Toolkit::Alignment *result = 0 ;
69328
69329   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69330   if (!arg1) {
69331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69332     return 0;
69333   }
69334   {
69335     try {
69336       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69337     } catch (std::out_of_range& e) {
69338       {
69339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69340       };
69341     } catch (std::exception& e) {
69342       {
69343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69344       };
69345     } catch (Dali::DaliException e) {
69346       {
69347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69348       };
69349     } catch (...) {
69350       {
69351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69352       };
69353     }
69354   }
69355
69356   jresult = (void *)result;
69357   return jresult;
69358 }
69359
69360
69361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69362   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69363
69364   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69365   {
69366     try {
69367       delete arg1;
69368     } catch (std::out_of_range& e) {
69369       {
69370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69371       };
69372     } catch (std::exception& e) {
69373       {
69374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69375       };
69376     } catch (Dali::DaliException e) {
69377       {
69378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69379       };
69380     } catch (...) {
69381       {
69382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69383       };
69384     }
69385   }
69386
69387 }
69388
69389
69390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69391   void * jresult ;
69392   Dali::BaseHandle arg1 ;
69393   Dali::BaseHandle *argp1 ;
69394   Dali::Toolkit::Alignment result;
69395
69396   argp1 = (Dali::BaseHandle *)jarg1;
69397   if (!argp1) {
69398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69399     return 0;
69400   }
69401   arg1 = *argp1;
69402   {
69403     try {
69404       result = Dali::Toolkit::Alignment::DownCast(arg1);
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (Dali::DaliException e) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69416       };
69417     } catch (...) {
69418       {
69419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69420       };
69421     }
69422   }
69423
69424   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69425   return jresult;
69426 }
69427
69428
69429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69430   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69431   Dali::Toolkit::Alignment::Type arg2 ;
69432
69433   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69434   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69435   {
69436     try {
69437       (arg1)->SetAlignmentType(arg2);
69438     } catch (std::out_of_range& e) {
69439       {
69440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69441       };
69442     } catch (std::exception& e) {
69443       {
69444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69445       };
69446     } catch (Dali::DaliException e) {
69447       {
69448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69449       };
69450     } catch (...) {
69451       {
69452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69453       };
69454     }
69455   }
69456
69457 }
69458
69459
69460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69461   int jresult ;
69462   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69463   Dali::Toolkit::Alignment::Type result;
69464
69465   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69466   {
69467     try {
69468       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69469     } catch (std::out_of_range& e) {
69470       {
69471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69472       };
69473     } catch (std::exception& e) {
69474       {
69475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69476       };
69477     } catch (Dali::DaliException e) {
69478       {
69479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69480       };
69481     } catch (...) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69484       };
69485     }
69486   }
69487
69488   jresult = (int)result;
69489   return jresult;
69490 }
69491
69492
69493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69494   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69495   Dali::Toolkit::Alignment::Scaling arg2 ;
69496
69497   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69498   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69499   {
69500     try {
69501       (arg1)->SetScaling(arg2);
69502     } catch (std::out_of_range& e) {
69503       {
69504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69505       };
69506     } catch (std::exception& e) {
69507       {
69508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69509       };
69510     } catch (Dali::DaliException e) {
69511       {
69512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69513       };
69514     } catch (...) {
69515       {
69516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69517       };
69518     }
69519   }
69520
69521 }
69522
69523
69524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69525   int jresult ;
69526   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69527   Dali::Toolkit::Alignment::Scaling result;
69528
69529   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69530   {
69531     try {
69532       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69533     } catch (std::out_of_range& e) {
69534       {
69535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69536       };
69537     } catch (std::exception& e) {
69538       {
69539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (Dali::DaliException e) {
69542       {
69543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69544       };
69545     } catch (...) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69548       };
69549     }
69550   }
69551
69552   jresult = (int)result;
69553   return jresult;
69554 }
69555
69556
69557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69558   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69559   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69560
69561   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69562   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69563   if (!arg2) {
69564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69565     return ;
69566   }
69567   {
69568     try {
69569       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69570     } catch (std::out_of_range& e) {
69571       {
69572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69573       };
69574     } catch (std::exception& e) {
69575       {
69576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69577       };
69578     } catch (Dali::DaliException e) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69581       };
69582     } catch (...) {
69583       {
69584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69585       };
69586     }
69587   }
69588
69589 }
69590
69591
69592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69593   void * jresult ;
69594   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69595   Dali::Toolkit::Alignment::Padding *result = 0 ;
69596
69597   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69598   {
69599     try {
69600       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69601     } catch (std::out_of_range& e) {
69602       {
69603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69604       };
69605     } catch (std::exception& e) {
69606       {
69607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69608       };
69609     } catch (Dali::DaliException e) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69616       };
69617     }
69618   }
69619
69620   jresult = (void *)result;
69621   return jresult;
69622 }
69623
69624
69625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69626   void * jresult ;
69627   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69628   Dali::Toolkit::Alignment *arg2 = 0 ;
69629   Dali::Toolkit::Alignment *result = 0 ;
69630
69631   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69632   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69633   if (!arg2) {
69634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69635     return 0;
69636   }
69637   {
69638     try {
69639       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69640     } catch (std::out_of_range& e) {
69641       {
69642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69643       };
69644     } catch (std::exception& e) {
69645       {
69646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69647       };
69648     } catch (Dali::DaliException e) {
69649       {
69650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69651       };
69652     } catch (...) {
69653       {
69654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69655       };
69656     }
69657   }
69658
69659   jresult = (void *)result;
69660   return jresult;
69661 }
69662
69663
69664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69665   int jresult ;
69666   int result;
69667
69668   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69669   jresult = (int)result;
69670   return jresult;
69671 }
69672
69673
69674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69675   int jresult ;
69676   int result;
69677
69678   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69679   jresult = (int)result;
69680   return jresult;
69681 }
69682
69683
69684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69685   int jresult ;
69686   int result;
69687
69688   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69689   jresult = (int)result;
69690   return jresult;
69691 }
69692
69693
69694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69695   int jresult ;
69696   int result;
69697
69698   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69699   jresult = (int)result;
69700   return jresult;
69701 }
69702
69703
69704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69705   int jresult ;
69706   int result;
69707
69708   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69709   jresult = (int)result;
69710   return jresult;
69711 }
69712
69713
69714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69715   int jresult ;
69716   int result;
69717
69718   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69719   jresult = (int)result;
69720   return jresult;
69721 }
69722
69723
69724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69725   int jresult ;
69726   int result;
69727
69728   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69729   jresult = (int)result;
69730   return jresult;
69731 }
69732
69733
69734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69735   int jresult ;
69736   int result;
69737
69738   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69739   jresult = (int)result;
69740   return jresult;
69741 }
69742
69743
69744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69745   int jresult ;
69746   int result;
69747
69748   result = (int)Dali::Toolkit::Button::Property::LABEL;
69749   jresult = (int)result;
69750   return jresult;
69751 }
69752
69753
69754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69755   int jresult ;
69756   int result;
69757
69758   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69759   jresult = (int)result;
69760   return jresult;
69761 }
69762
69763
69764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69765   void * jresult ;
69766   Dali::Toolkit::Button::Property *result = 0 ;
69767
69768   {
69769     try {
69770       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69771     } catch (std::out_of_range& e) {
69772       {
69773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69774       };
69775     } catch (std::exception& e) {
69776       {
69777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69778       };
69779     } catch (Dali::DaliException e) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69786       };
69787     }
69788   }
69789
69790   jresult = (void *)result;
69791   return jresult;
69792 }
69793
69794
69795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69796   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69797
69798   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69799   {
69800     try {
69801       delete arg1;
69802     } catch (std::out_of_range& e) {
69803       {
69804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69805       };
69806     } catch (std::exception& e) {
69807       {
69808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69809       };
69810     } catch (Dali::DaliException e) {
69811       {
69812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69813       };
69814     } catch (...) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69817       };
69818     }
69819   }
69820
69821 }
69822
69823
69824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69825   void * jresult ;
69826   Dali::Toolkit::Button *result = 0 ;
69827
69828   {
69829     try {
69830       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69831     } catch (std::out_of_range& e) {
69832       {
69833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (std::exception& e) {
69836       {
69837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (Dali::DaliException e) {
69840       {
69841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69842       };
69843     } catch (...) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69846       };
69847     }
69848   }
69849
69850   jresult = (void *)result;
69851   return jresult;
69852 }
69853
69854
69855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69856   void * jresult ;
69857   Dali::Toolkit::Button *arg1 = 0 ;
69858   Dali::Toolkit::Button *result = 0 ;
69859
69860   arg1 = (Dali::Toolkit::Button *)jarg1;
69861   if (!arg1) {
69862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69863     return 0;
69864   }
69865   {
69866     try {
69867       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69868     } catch (std::out_of_range& e) {
69869       {
69870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69871       };
69872     } catch (std::exception& e) {
69873       {
69874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69875       };
69876     } catch (Dali::DaliException e) {
69877       {
69878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69879       };
69880     } catch (...) {
69881       {
69882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69883       };
69884     }
69885   }
69886
69887   jresult = (void *)result;
69888   return jresult;
69889 }
69890
69891
69892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69893   void * jresult ;
69894   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69895   Dali::Toolkit::Button *arg2 = 0 ;
69896   Dali::Toolkit::Button *result = 0 ;
69897
69898   arg1 = (Dali::Toolkit::Button *)jarg1;
69899   arg2 = (Dali::Toolkit::Button *)jarg2;
69900   if (!arg2) {
69901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69902     return 0;
69903   }
69904   {
69905     try {
69906       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69907     } catch (std::out_of_range& e) {
69908       {
69909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69910       };
69911     } catch (std::exception& e) {
69912       {
69913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69914       };
69915     } catch (Dali::DaliException e) {
69916       {
69917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69918       };
69919     } catch (...) {
69920       {
69921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69922       };
69923     }
69924   }
69925
69926   jresult = (void *)result;
69927   return jresult;
69928 }
69929
69930
69931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69932   void * jresult ;
69933   Dali::BaseHandle arg1 ;
69934   Dali::BaseHandle *argp1 ;
69935   Dali::Toolkit::Button result;
69936
69937   argp1 = (Dali::BaseHandle *)jarg1;
69938   if (!argp1) {
69939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69940     return 0;
69941   }
69942   arg1 = *argp1;
69943   {
69944     try {
69945       result = Dali::Toolkit::Button::DownCast(arg1);
69946     } catch (std::out_of_range& e) {
69947       {
69948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (std::exception& e) {
69951       {
69952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69953       };
69954     } catch (Dali::DaliException e) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69957       };
69958     } catch (...) {
69959       {
69960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69961       };
69962     }
69963   }
69964
69965   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69966   return jresult;
69967 }
69968
69969
69970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69971   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69972
69973   arg1 = (Dali::Toolkit::Button *)jarg1;
69974   {
69975     try {
69976       delete arg1;
69977     } catch (std::out_of_range& e) {
69978       {
69979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69980       };
69981     } catch (std::exception& e) {
69982       {
69983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69984       };
69985     } catch (Dali::DaliException e) {
69986       {
69987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69988       };
69989     } catch (...) {
69990       {
69991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69992       };
69993     }
69994   }
69995
69996 }
69997
69998
69999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70000   unsigned int jresult ;
70001   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70002   bool result;
70003
70004   arg1 = (Dali::Toolkit::Button *)jarg1;
70005   {
70006     try {
70007       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70008     } catch (std::out_of_range& e) {
70009       {
70010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70011       };
70012     } catch (std::exception& e) {
70013       {
70014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70015       };
70016     } catch (Dali::DaliException e) {
70017       {
70018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70019       };
70020     } catch (...) {
70021       {
70022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70023       };
70024     }
70025   }
70026
70027   jresult = result;
70028   return jresult;
70029 }
70030
70031
70032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70033   unsigned int jresult ;
70034   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70035   bool result;
70036
70037   arg1 = (Dali::Toolkit::Button *)jarg1;
70038   {
70039     try {
70040       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70041     } catch (std::out_of_range& e) {
70042       {
70043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70044       };
70045     } catch (std::exception& e) {
70046       {
70047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (Dali::DaliException e) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70052       };
70053     } catch (...) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70056       };
70057     }
70058   }
70059
70060   jresult = result;
70061   return jresult;
70062 }
70063
70064
70065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70066   float jresult ;
70067   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70068   float result;
70069
70070   arg1 = (Dali::Toolkit::Button *)jarg1;
70071   {
70072     try {
70073       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70074     } catch (std::out_of_range& e) {
70075       {
70076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70077       };
70078     } catch (std::exception& e) {
70079       {
70080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70081       };
70082     } catch (Dali::DaliException e) {
70083       {
70084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70085       };
70086     } catch (...) {
70087       {
70088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70089       };
70090     }
70091   }
70092
70093   jresult = result;
70094   return jresult;
70095 }
70096
70097
70098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70099   float jresult ;
70100   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70101   float result;
70102
70103   arg1 = (Dali::Toolkit::Button *)jarg1;
70104   {
70105     try {
70106       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70107     } catch (std::out_of_range& e) {
70108       {
70109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70110       };
70111     } catch (std::exception& e) {
70112       {
70113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (Dali::DaliException e) {
70116       {
70117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70118       };
70119     } catch (...) {
70120       {
70121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70122       };
70123     }
70124   }
70125
70126   jresult = result;
70127   return jresult;
70128 }
70129
70130
70131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70132   unsigned int jresult ;
70133   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70134   bool result;
70135
70136   arg1 = (Dali::Toolkit::Button *)jarg1;
70137   {
70138     try {
70139       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70140     } catch (std::out_of_range& e) {
70141       {
70142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70143       };
70144     } catch (std::exception& e) {
70145       {
70146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70147       };
70148     } catch (Dali::DaliException e) {
70149       {
70150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70151       };
70152     } catch (...) {
70153       {
70154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70155       };
70156     }
70157   }
70158
70159   jresult = result;
70160   return jresult;
70161 }
70162
70163
70164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70165   unsigned int jresult ;
70166   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70167   bool result;
70168
70169   arg1 = (Dali::Toolkit::Button *)jarg1;
70170   {
70171     try {
70172       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70173     } catch (std::out_of_range& e) {
70174       {
70175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70176       };
70177     } catch (std::exception& e) {
70178       {
70179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70180       };
70181     } catch (Dali::DaliException e) {
70182       {
70183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70184       };
70185     } catch (...) {
70186       {
70187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70188       };
70189     }
70190   }
70191
70192   jresult = result;
70193   return jresult;
70194 }
70195
70196
70197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70198   float jresult ;
70199   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70200   float result;
70201
70202   arg1 = (Dali::Toolkit::Button *)jarg1;
70203   {
70204     try {
70205       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70206     } catch (std::out_of_range& e) {
70207       {
70208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70209       };
70210     } catch (std::exception& e) {
70211       {
70212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70213       };
70214     } catch (Dali::DaliException e) {
70215       {
70216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70217       };
70218     } catch (...) {
70219       {
70220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70221       };
70222     }
70223   }
70224
70225   jresult = result;
70226   return jresult;
70227 }
70228
70229
70230 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70231   char * jresult ;
70232   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70233   std::string result;
70234
70235   arg1 = (Dali::Toolkit::Button *)jarg1;
70236   {
70237     try {
70238       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70239     } catch (std::out_of_range& e) {
70240       {
70241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70242       };
70243     } catch (std::exception& e) {
70244       {
70245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70246       };
70247     } catch (Dali::DaliException e) {
70248       {
70249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70250       };
70251     } catch (...) {
70252       {
70253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70254       };
70255     }
70256   }
70257
70258   jresult = SWIG_csharp_string_callback((&result)->c_str());
70259   return jresult;
70260 }
70261
70262
70263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70264   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70265   Dali::Actor arg2 ;
70266   Dali::Actor *argp2 ;
70267
70268   arg1 = (Dali::Toolkit::Button *)jarg1;
70269   argp2 = (Dali::Actor *)jarg2;
70270   if (!argp2) {
70271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70272     return ;
70273   }
70274   arg2 = *argp2;
70275   {
70276     try {
70277       (arg1)->SetLabel(arg2);
70278     } catch (std::out_of_range& e) {
70279       {
70280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70281       };
70282     } catch (std::exception& e) {
70283       {
70284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70285       };
70286     } catch (Dali::DaliException e) {
70287       {
70288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70289       };
70290     } catch (...) {
70291       {
70292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70293       };
70294     }
70295   }
70296
70297 }
70298
70299
70300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70301   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70302   Dali::Image arg2 ;
70303   Dali::Image *argp2 ;
70304
70305   arg1 = (Dali::Toolkit::Button *)jarg1;
70306   argp2 = (Dali::Image *)jarg2;
70307   if (!argp2) {
70308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70309     return ;
70310   }
70311   arg2 = *argp2;
70312   {
70313     try {
70314       (arg1)->SetButtonImage(arg2);
70315     } catch (std::out_of_range& e) {
70316       {
70317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70318       };
70319     } catch (std::exception& e) {
70320       {
70321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70322       };
70323     } catch (Dali::DaliException e) {
70324       {
70325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70326       };
70327     } catch (...) {
70328       {
70329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70330       };
70331     }
70332   }
70333
70334 }
70335
70336
70337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70338   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70339   Dali::Image arg2 ;
70340   Dali::Image *argp2 ;
70341
70342   arg1 = (Dali::Toolkit::Button *)jarg1;
70343   argp2 = (Dali::Image *)jarg2;
70344   if (!argp2) {
70345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70346     return ;
70347   }
70348   arg2 = *argp2;
70349   {
70350     try {
70351       (arg1)->SetSelectedImage(arg2);
70352     } catch (std::out_of_range& e) {
70353       {
70354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70355       };
70356     } catch (std::exception& e) {
70357       {
70358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70359       };
70360     } catch (Dali::DaliException e) {
70361       {
70362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70363       };
70364     } catch (...) {
70365       {
70366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70367       };
70368     }
70369   }
70370
70371 }
70372
70373
70374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70375   void * jresult ;
70376   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70377   Dali::Actor result;
70378
70379   arg1 = (Dali::Toolkit::Button *)jarg1;
70380   {
70381     try {
70382       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70383     } catch (std::out_of_range& e) {
70384       {
70385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70386       };
70387     } catch (std::exception& e) {
70388       {
70389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70390       };
70391     } catch (Dali::DaliException e) {
70392       {
70393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70394       };
70395     } catch (...) {
70396       {
70397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70398       };
70399     }
70400   }
70401
70402   jresult = new Dali::Actor((const Dali::Actor &)result);
70403   return jresult;
70404 }
70405
70406
70407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70408   void * jresult ;
70409   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70410   Dali::Actor result;
70411
70412   arg1 = (Dali::Toolkit::Button *)jarg1;
70413   {
70414     try {
70415       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70416     } catch (std::out_of_range& e) {
70417       {
70418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70419       };
70420     } catch (std::exception& e) {
70421       {
70422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70423       };
70424     } catch (Dali::DaliException e) {
70425       {
70426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70427       };
70428     } catch (...) {
70429       {
70430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70431       };
70432     }
70433   }
70434
70435   jresult = new Dali::Actor((const Dali::Actor &)result);
70436   return jresult;
70437 }
70438
70439
70440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70441   void * jresult ;
70442   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70443   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70444
70445   arg1 = (Dali::Toolkit::Button *)jarg1;
70446   {
70447     try {
70448       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70449     } catch (std::out_of_range& e) {
70450       {
70451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70452       };
70453     } catch (std::exception& e) {
70454       {
70455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70456       };
70457     } catch (Dali::DaliException e) {
70458       {
70459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70460       };
70461     } catch (...) {
70462       {
70463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70464       };
70465     }
70466   }
70467
70468   jresult = (void *)result;
70469   return jresult;
70470 }
70471
70472
70473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70474   void * jresult ;
70475   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70476   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70477
70478   arg1 = (Dali::Toolkit::Button *)jarg1;
70479   {
70480     try {
70481       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70482     } catch (std::out_of_range& e) {
70483       {
70484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70485       };
70486     } catch (std::exception& e) {
70487       {
70488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70489       };
70490     } catch (Dali::DaliException e) {
70491       {
70492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70493       };
70494     } catch (...) {
70495       {
70496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70497       };
70498     }
70499   }
70500
70501   jresult = (void *)result;
70502   return jresult;
70503 }
70504
70505
70506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70507   void * jresult ;
70508   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70509   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70510
70511   arg1 = (Dali::Toolkit::Button *)jarg1;
70512   {
70513     try {
70514       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70515     } catch (std::out_of_range& e) {
70516       {
70517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70518       };
70519     } catch (std::exception& e) {
70520       {
70521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70522       };
70523     } catch (Dali::DaliException e) {
70524       {
70525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70526       };
70527     } catch (...) {
70528       {
70529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70530       };
70531     }
70532   }
70533
70534   jresult = (void *)result;
70535   return jresult;
70536 }
70537
70538
70539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70540   void * jresult ;
70541   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70542   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70543
70544   arg1 = (Dali::Toolkit::Button *)jarg1;
70545   {
70546     try {
70547       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70548     } catch (std::out_of_range& e) {
70549       {
70550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70551       };
70552     } catch (std::exception& e) {
70553       {
70554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70555       };
70556     } catch (Dali::DaliException e) {
70557       {
70558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70559       };
70560     } catch (...) {
70561       {
70562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70563       };
70564     }
70565   }
70566
70567   jresult = (void *)result;
70568   return jresult;
70569 }
70570
70571
70572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70573   void * jresult ;
70574   Dali::Toolkit::CheckBoxButton *result = 0 ;
70575
70576   {
70577     try {
70578       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70579     } catch (std::out_of_range& e) {
70580       {
70581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70582       };
70583     } catch (std::exception& e) {
70584       {
70585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70586       };
70587     } catch (Dali::DaliException e) {
70588       {
70589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70590       };
70591     } catch (...) {
70592       {
70593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70594       };
70595     }
70596   }
70597
70598   jresult = (void *)result;
70599   return jresult;
70600 }
70601
70602
70603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70604   void * jresult ;
70605   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70606   Dali::Toolkit::CheckBoxButton *result = 0 ;
70607
70608   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70609   if (!arg1) {
70610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70611     return 0;
70612   }
70613   {
70614     try {
70615       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70616     } catch (std::out_of_range& e) {
70617       {
70618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70619       };
70620     } catch (std::exception& e) {
70621       {
70622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70623       };
70624     } catch (Dali::DaliException e) {
70625       {
70626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70627       };
70628     } catch (...) {
70629       {
70630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70631       };
70632     }
70633   }
70634
70635   jresult = (void *)result;
70636   return jresult;
70637 }
70638
70639
70640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70641   void * jresult ;
70642   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70643   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70644   Dali::Toolkit::CheckBoxButton *result = 0 ;
70645
70646   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70647   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70648   if (!arg2) {
70649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70650     return 0;
70651   }
70652   {
70653     try {
70654       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70655     } catch (std::out_of_range& e) {
70656       {
70657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70658       };
70659     } catch (std::exception& e) {
70660       {
70661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70662       };
70663     } catch (Dali::DaliException e) {
70664       {
70665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70666       };
70667     } catch (...) {
70668       {
70669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70670       };
70671     }
70672   }
70673
70674   jresult = (void *)result;
70675   return jresult;
70676 }
70677
70678
70679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70680   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70681
70682   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70683   {
70684     try {
70685       delete arg1;
70686     } catch (std::out_of_range& e) {
70687       {
70688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70689       };
70690     } catch (std::exception& e) {
70691       {
70692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70693       };
70694     } catch (Dali::DaliException e) {
70695       {
70696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70697       };
70698     } catch (...) {
70699       {
70700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70701       };
70702     }
70703   }
70704
70705 }
70706
70707
70708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70709   void * jresult ;
70710   Dali::Toolkit::CheckBoxButton result;
70711
70712   {
70713     try {
70714       result = Dali::Toolkit::CheckBoxButton::New();
70715     } catch (std::out_of_range& e) {
70716       {
70717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70718       };
70719     } catch (std::exception& e) {
70720       {
70721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70722       };
70723     } catch (Dali::DaliException e) {
70724       {
70725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70726       };
70727     } catch (...) {
70728       {
70729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70730       };
70731     }
70732   }
70733
70734   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70735   return jresult;
70736 }
70737
70738
70739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70740   void * jresult ;
70741   Dali::BaseHandle arg1 ;
70742   Dali::BaseHandle *argp1 ;
70743   Dali::Toolkit::CheckBoxButton result;
70744
70745   argp1 = (Dali::BaseHandle *)jarg1;
70746   if (!argp1) {
70747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70748     return 0;
70749   }
70750   arg1 = *argp1;
70751   {
70752     try {
70753       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70754     } catch (std::out_of_range& e) {
70755       {
70756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70757       };
70758     } catch (std::exception& e) {
70759       {
70760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70761       };
70762     } catch (Dali::DaliException e) {
70763       {
70764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70765       };
70766     } catch (...) {
70767       {
70768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70769       };
70770     }
70771   }
70772
70773   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70774   return jresult;
70775 }
70776
70777
70778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70779   int jresult ;
70780   int result;
70781
70782   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70783   jresult = (int)result;
70784   return jresult;
70785 }
70786
70787
70788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70789   int jresult ;
70790   int result;
70791
70792   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70793   jresult = (int)result;
70794   return jresult;
70795 }
70796
70797
70798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70799   int jresult ;
70800   int result;
70801
70802   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70803   jresult = (int)result;
70804   return jresult;
70805 }
70806
70807
70808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70809   int jresult ;
70810   int result;
70811
70812   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70813   jresult = (int)result;
70814   return jresult;
70815 }
70816
70817
70818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70819   int jresult ;
70820   int result;
70821
70822   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70823   jresult = (int)result;
70824   return jresult;
70825 }
70826
70827
70828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70829   void * jresult ;
70830   Dali::Toolkit::PushButton::Property *result = 0 ;
70831
70832   {
70833     try {
70834       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70835     } catch (std::out_of_range& e) {
70836       {
70837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70838       };
70839     } catch (std::exception& e) {
70840       {
70841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70842       };
70843     } catch (Dali::DaliException e) {
70844       {
70845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70846       };
70847     } catch (...) {
70848       {
70849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70850       };
70851     }
70852   }
70853
70854   jresult = (void *)result;
70855   return jresult;
70856 }
70857
70858
70859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70860   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70861
70862   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70863   {
70864     try {
70865       delete arg1;
70866     } catch (std::out_of_range& e) {
70867       {
70868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70869       };
70870     } catch (std::exception& e) {
70871       {
70872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70873       };
70874     } catch (Dali::DaliException e) {
70875       {
70876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70877       };
70878     } catch (...) {
70879       {
70880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70881       };
70882     }
70883   }
70884
70885 }
70886
70887
70888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70889   void * jresult ;
70890   Dali::Toolkit::PushButton *result = 0 ;
70891
70892   {
70893     try {
70894       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70895     } catch (std::out_of_range& e) {
70896       {
70897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70898       };
70899     } catch (std::exception& e) {
70900       {
70901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70902       };
70903     } catch (Dali::DaliException e) {
70904       {
70905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70906       };
70907     } catch (...) {
70908       {
70909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70910       };
70911     }
70912   }
70913
70914   jresult = (void *)result;
70915   return jresult;
70916 }
70917
70918
70919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70920   void * jresult ;
70921   Dali::Toolkit::PushButton *arg1 = 0 ;
70922   Dali::Toolkit::PushButton *result = 0 ;
70923
70924   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70925   if (!arg1) {
70926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70927     return 0;
70928   }
70929   {
70930     try {
70931       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70932     } catch (std::out_of_range& e) {
70933       {
70934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70935       };
70936     } catch (std::exception& e) {
70937       {
70938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70939       };
70940     } catch (Dali::DaliException e) {
70941       {
70942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70943       };
70944     } catch (...) {
70945       {
70946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70947       };
70948     }
70949   }
70950
70951   jresult = (void *)result;
70952   return jresult;
70953 }
70954
70955
70956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70957   void * jresult ;
70958   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70959   Dali::Toolkit::PushButton *arg2 = 0 ;
70960   Dali::Toolkit::PushButton *result = 0 ;
70961
70962   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70963   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70964   if (!arg2) {
70965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70966     return 0;
70967   }
70968   {
70969     try {
70970       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70971     } catch (std::out_of_range& e) {
70972       {
70973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70974       };
70975     } catch (std::exception& e) {
70976       {
70977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70978       };
70979     } catch (Dali::DaliException e) {
70980       {
70981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70982       };
70983     } catch (...) {
70984       {
70985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70986       };
70987     }
70988   }
70989
70990   jresult = (void *)result;
70991   return jresult;
70992 }
70993
70994
70995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70996   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70997
70998   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70999   {
71000     try {
71001       delete arg1;
71002     } catch (std::out_of_range& e) {
71003       {
71004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71005       };
71006     } catch (std::exception& e) {
71007       {
71008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71009       };
71010     } catch (Dali::DaliException e) {
71011       {
71012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71013       };
71014     } catch (...) {
71015       {
71016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71017       };
71018     }
71019   }
71020
71021 }
71022
71023
71024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71025   void * jresult ;
71026   Dali::Toolkit::PushButton result;
71027
71028   {
71029     try {
71030       result = Dali::Toolkit::PushButton::New();
71031     } catch (std::out_of_range& e) {
71032       {
71033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71034       };
71035     } catch (std::exception& e) {
71036       {
71037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71038       };
71039     } catch (Dali::DaliException e) {
71040       {
71041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71042       };
71043     } catch (...) {
71044       {
71045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71046       };
71047     }
71048   }
71049
71050   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71051   return jresult;
71052 }
71053
71054
71055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71056   void * jresult ;
71057   Dali::BaseHandle arg1 ;
71058   Dali::BaseHandle *argp1 ;
71059   Dali::Toolkit::PushButton result;
71060
71061   argp1 = (Dali::BaseHandle *)jarg1;
71062   if (!argp1) {
71063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71064     return 0;
71065   }
71066   arg1 = *argp1;
71067   {
71068     try {
71069       result = Dali::Toolkit::PushButton::DownCast(arg1);
71070     } catch (std::out_of_range& e) {
71071       {
71072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71073       };
71074     } catch (std::exception& e) {
71075       {
71076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71077       };
71078     } catch (Dali::DaliException e) {
71079       {
71080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71081       };
71082     } catch (...) {
71083       {
71084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71085       };
71086     }
71087   }
71088
71089   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71090   return jresult;
71091 }
71092
71093
71094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71095   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71096   Dali::Image arg2 ;
71097   Dali::Image *argp2 ;
71098
71099   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71100   argp2 = (Dali::Image *)jarg2;
71101   if (!argp2) {
71102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71103     return ;
71104   }
71105   arg2 = *argp2;
71106   {
71107     try {
71108       (arg1)->SetButtonImage(arg2);
71109     } catch (std::out_of_range& e) {
71110       {
71111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71112       };
71113     } catch (std::exception& e) {
71114       {
71115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71116       };
71117     } catch (Dali::DaliException e) {
71118       {
71119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71120       };
71121     } catch (...) {
71122       {
71123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71124       };
71125     }
71126   }
71127
71128 }
71129
71130
71131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71132   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71133   Dali::Actor arg2 ;
71134   Dali::Actor *argp2 ;
71135
71136   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71137   argp2 = (Dali::Actor *)jarg2;
71138   if (!argp2) {
71139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71140     return ;
71141   }
71142   arg2 = *argp2;
71143   {
71144     try {
71145       (arg1)->SetButtonImage(arg2);
71146     } catch (std::out_of_range& e) {
71147       {
71148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71149       };
71150     } catch (std::exception& e) {
71151       {
71152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71153       };
71154     } catch (Dali::DaliException e) {
71155       {
71156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71157       };
71158     } catch (...) {
71159       {
71160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71161       };
71162     }
71163   }
71164
71165 }
71166
71167
71168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71169   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71170   Dali::Actor arg2 ;
71171   Dali::Actor *argp2 ;
71172
71173   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71174   argp2 = (Dali::Actor *)jarg2;
71175   if (!argp2) {
71176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71177     return ;
71178   }
71179   arg2 = *argp2;
71180   {
71181     try {
71182       (arg1)->SetBackgroundImage(arg2);
71183     } catch (std::out_of_range& e) {
71184       {
71185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71186       };
71187     } catch (std::exception& e) {
71188       {
71189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71190       };
71191     } catch (Dali::DaliException e) {
71192       {
71193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71194       };
71195     } catch (...) {
71196       {
71197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71198       };
71199     }
71200   }
71201
71202 }
71203
71204
71205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71206   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71207   Dali::Image arg2 ;
71208   Dali::Image *argp2 ;
71209
71210   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71211   argp2 = (Dali::Image *)jarg2;
71212   if (!argp2) {
71213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71214     return ;
71215   }
71216   arg2 = *argp2;
71217   {
71218     try {
71219       (arg1)->SetSelectedImage(arg2);
71220     } catch (std::out_of_range& e) {
71221       {
71222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71223       };
71224     } catch (std::exception& e) {
71225       {
71226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71227       };
71228     } catch (Dali::DaliException e) {
71229       {
71230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71231       };
71232     } catch (...) {
71233       {
71234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71235       };
71236     }
71237   }
71238
71239 }
71240
71241
71242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71243   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71244   Dali::Actor arg2 ;
71245   Dali::Actor *argp2 ;
71246
71247   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71248   argp2 = (Dali::Actor *)jarg2;
71249   if (!argp2) {
71250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71251     return ;
71252   }
71253   arg2 = *argp2;
71254   {
71255     try {
71256       (arg1)->SetSelectedImage(arg2);
71257     } catch (std::out_of_range& e) {
71258       {
71259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71260       };
71261     } catch (std::exception& e) {
71262       {
71263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71264       };
71265     } catch (Dali::DaliException e) {
71266       {
71267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71268       };
71269     } catch (...) {
71270       {
71271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71272       };
71273     }
71274   }
71275
71276 }
71277
71278
71279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71280   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71281   Dali::Actor arg2 ;
71282   Dali::Actor *argp2 ;
71283
71284   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71285   argp2 = (Dali::Actor *)jarg2;
71286   if (!argp2) {
71287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71288     return ;
71289   }
71290   arg2 = *argp2;
71291   {
71292     try {
71293       (arg1)->SetSelectedBackgroundImage(arg2);
71294     } catch (std::out_of_range& e) {
71295       {
71296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71297       };
71298     } catch (std::exception& e) {
71299       {
71300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71301       };
71302     } catch (Dali::DaliException e) {
71303       {
71304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71305       };
71306     } catch (...) {
71307       {
71308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71309       };
71310     }
71311   }
71312
71313 }
71314
71315
71316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71317   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71318   Dali::Actor arg2 ;
71319   Dali::Actor *argp2 ;
71320
71321   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71322   argp2 = (Dali::Actor *)jarg2;
71323   if (!argp2) {
71324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71325     return ;
71326   }
71327   arg2 = *argp2;
71328   {
71329     try {
71330       (arg1)->SetDisabledBackgroundImage(arg2);
71331     } catch (std::out_of_range& e) {
71332       {
71333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71334       };
71335     } catch (std::exception& e) {
71336       {
71337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71338       };
71339     } catch (Dali::DaliException e) {
71340       {
71341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71342       };
71343     } catch (...) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71346       };
71347     }
71348   }
71349
71350 }
71351
71352
71353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71354   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71355   Dali::Actor arg2 ;
71356   Dali::Actor *argp2 ;
71357
71358   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71359   argp2 = (Dali::Actor *)jarg2;
71360   if (!argp2) {
71361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71362     return ;
71363   }
71364   arg2 = *argp2;
71365   {
71366     try {
71367       (arg1)->SetDisabledImage(arg2);
71368     } catch (std::out_of_range& e) {
71369       {
71370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71371       };
71372     } catch (std::exception& e) {
71373       {
71374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71375       };
71376     } catch (Dali::DaliException e) {
71377       {
71378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71379       };
71380     } catch (...) {
71381       {
71382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71383       };
71384     }
71385   }
71386
71387 }
71388
71389
71390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71391   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71392   Dali::Actor arg2 ;
71393   Dali::Actor *argp2 ;
71394
71395   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71396   argp2 = (Dali::Actor *)jarg2;
71397   if (!argp2) {
71398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71399     return ;
71400   }
71401   arg2 = *argp2;
71402   {
71403     try {
71404       (arg1)->SetDisabledSelectedImage(arg2);
71405     } catch (std::out_of_range& e) {
71406       {
71407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71408       };
71409     } catch (std::exception& e) {
71410       {
71411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71412       };
71413     } catch (Dali::DaliException e) {
71414       {
71415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71416       };
71417     } catch (...) {
71418       {
71419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71420       };
71421     }
71422   }
71423
71424 }
71425
71426
71427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71428   void * jresult ;
71429   Dali::Toolkit::RadioButton *result = 0 ;
71430
71431   {
71432     try {
71433       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71434     } catch (std::out_of_range& e) {
71435       {
71436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71437       };
71438     } catch (std::exception& e) {
71439       {
71440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71441       };
71442     } catch (Dali::DaliException e) {
71443       {
71444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71445       };
71446     } catch (...) {
71447       {
71448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71449       };
71450     }
71451   }
71452
71453   jresult = (void *)result;
71454   return jresult;
71455 }
71456
71457
71458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71459   void * jresult ;
71460   Dali::Toolkit::RadioButton *arg1 = 0 ;
71461   Dali::Toolkit::RadioButton *result = 0 ;
71462
71463   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71464   if (!arg1) {
71465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71466     return 0;
71467   }
71468   {
71469     try {
71470       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71471     } catch (std::out_of_range& e) {
71472       {
71473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71474       };
71475     } catch (std::exception& e) {
71476       {
71477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71478       };
71479     } catch (Dali::DaliException e) {
71480       {
71481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71482       };
71483     } catch (...) {
71484       {
71485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71486       };
71487     }
71488   }
71489
71490   jresult = (void *)result;
71491   return jresult;
71492 }
71493
71494
71495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71496   void * jresult ;
71497   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71498   Dali::Toolkit::RadioButton *arg2 = 0 ;
71499   Dali::Toolkit::RadioButton *result = 0 ;
71500
71501   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71502   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71503   if (!arg2) {
71504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71505     return 0;
71506   }
71507   {
71508     try {
71509       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71510     } catch (std::out_of_range& e) {
71511       {
71512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71513       };
71514     } catch (std::exception& e) {
71515       {
71516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71517       };
71518     } catch (Dali::DaliException e) {
71519       {
71520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71521       };
71522     } catch (...) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71525       };
71526     }
71527   }
71528
71529   jresult = (void *)result;
71530   return jresult;
71531 }
71532
71533
71534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71535   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71536
71537   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71538   {
71539     try {
71540       delete arg1;
71541     } catch (std::out_of_range& e) {
71542       {
71543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71544       };
71545     } catch (std::exception& e) {
71546       {
71547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71548       };
71549     } catch (Dali::DaliException e) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71552       };
71553     } catch (...) {
71554       {
71555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71556       };
71557     }
71558   }
71559
71560 }
71561
71562
71563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71564   void * jresult ;
71565   Dali::Toolkit::RadioButton result;
71566
71567   {
71568     try {
71569       result = Dali::Toolkit::RadioButton::New();
71570     } catch (std::out_of_range& e) {
71571       {
71572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71573       };
71574     } catch (std::exception& e) {
71575       {
71576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71577       };
71578     } catch (Dali::DaliException e) {
71579       {
71580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71581       };
71582     } catch (...) {
71583       {
71584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71585       };
71586     }
71587   }
71588
71589   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71590   return jresult;
71591 }
71592
71593
71594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71595   void * jresult ;
71596   std::string *arg1 = 0 ;
71597   Dali::Toolkit::RadioButton result;
71598
71599   if (!jarg1) {
71600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71601     return 0;
71602   }
71603   std::string arg1_str(jarg1);
71604   arg1 = &arg1_str;
71605   {
71606     try {
71607       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71608     } catch (std::out_of_range& e) {
71609       {
71610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71611       };
71612     } catch (std::exception& e) {
71613       {
71614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71615       };
71616     } catch (Dali::DaliException e) {
71617       {
71618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71619       };
71620     } catch (...) {
71621       {
71622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71623       };
71624     }
71625   }
71626
71627   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71628
71629   //argout typemap for const std::string&
71630
71631   return jresult;
71632 }
71633
71634
71635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71636   void * jresult ;
71637   Dali::BaseHandle arg1 ;
71638   Dali::BaseHandle *argp1 ;
71639   Dali::Toolkit::RadioButton result;
71640
71641   argp1 = (Dali::BaseHandle *)jarg1;
71642   if (!argp1) {
71643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71644     return 0;
71645   }
71646   arg1 = *argp1;
71647   {
71648     try {
71649       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71650     } catch (std::out_of_range& e) {
71651       {
71652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71653       };
71654     } catch (std::exception& e) {
71655       {
71656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71657       };
71658     } catch (Dali::DaliException e) {
71659       {
71660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71661       };
71662     } catch (...) {
71663       {
71664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71665       };
71666     }
71667   }
71668
71669   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71670   return jresult;
71671 }
71672
71673
71674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71675   int jresult ;
71676   int result;
71677
71678   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71679   jresult = (int)result;
71680   return jresult;
71681 }
71682
71683
71684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71685   int jresult ;
71686   int result;
71687
71688   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71689   jresult = (int)result;
71690   return jresult;
71691 }
71692
71693
71694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71695   int jresult ;
71696   int result;
71697
71698   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71699   jresult = (int)result;
71700   return jresult;
71701 }
71702
71703
71704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71705   int jresult ;
71706   int result;
71707
71708   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71709   jresult = (int)result;
71710   return jresult;
71711 }
71712
71713
71714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71715   int jresult ;
71716   int result;
71717
71718   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71719   jresult = (int)result;
71720   return jresult;
71721 }
71722
71723
71724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71725   int jresult ;
71726   int result;
71727
71728   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71729   jresult = (int)result;
71730   return jresult;
71731 }
71732
71733
71734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71735   void * jresult ;
71736   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71737
71738   {
71739     try {
71740       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71741     } catch (std::out_of_range& e) {
71742       {
71743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71744       };
71745     } catch (std::exception& e) {
71746       {
71747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71748       };
71749     } catch (Dali::DaliException e) {
71750       {
71751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71752       };
71753     } catch (...) {
71754       {
71755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71756       };
71757     }
71758   }
71759
71760   jresult = (void *)result;
71761   return jresult;
71762 }
71763
71764
71765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71766   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71767
71768   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71769   {
71770     try {
71771       delete arg1;
71772     } catch (std::out_of_range& e) {
71773       {
71774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71775       };
71776     } catch (std::exception& e) {
71777       {
71778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71779       };
71780     } catch (Dali::DaliException e) {
71781       {
71782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71783       };
71784     } catch (...) {
71785       {
71786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71787       };
71788     }
71789   }
71790
71791 }
71792
71793
71794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71795   int jresult ;
71796   int result;
71797
71798   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71799   jresult = (int)result;
71800   return jresult;
71801 }
71802
71803
71804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71805   int jresult ;
71806   int result;
71807
71808   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71809   jresult = (int)result;
71810   return jresult;
71811 }
71812
71813
71814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71815   int jresult ;
71816   int result;
71817
71818   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71819   jresult = (int)result;
71820   return jresult;
71821 }
71822
71823
71824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71825   void * jresult ;
71826   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71827
71828   {
71829     try {
71830       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71831     } catch (std::out_of_range& e) {
71832       {
71833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71834       };
71835     } catch (std::exception& e) {
71836       {
71837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71838       };
71839     } catch (Dali::DaliException e) {
71840       {
71841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71842       };
71843     } catch (...) {
71844       {
71845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71846       };
71847     }
71848   }
71849
71850   jresult = (void *)result;
71851   return jresult;
71852 }
71853
71854
71855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71856   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71857
71858   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71859   {
71860     try {
71861       delete arg1;
71862     } catch (std::out_of_range& e) {
71863       {
71864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71865       };
71866     } catch (std::exception& e) {
71867       {
71868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71869       };
71870     } catch (Dali::DaliException e) {
71871       {
71872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71873       };
71874     } catch (...) {
71875       {
71876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71877       };
71878     }
71879   }
71880
71881 }
71882
71883
71884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71885   void * jresult ;
71886   Dali::Toolkit::FlexContainer *result = 0 ;
71887
71888   {
71889     try {
71890       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71891     } catch (std::out_of_range& e) {
71892       {
71893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71894       };
71895     } catch (std::exception& e) {
71896       {
71897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71898       };
71899     } catch (Dali::DaliException e) {
71900       {
71901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71902       };
71903     } catch (...) {
71904       {
71905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71906       };
71907     }
71908   }
71909
71910   jresult = (void *)result;
71911   return jresult;
71912 }
71913
71914
71915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71916   void * jresult ;
71917   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71918   Dali::Toolkit::FlexContainer *result = 0 ;
71919
71920   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71921   if (!arg1) {
71922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71923     return 0;
71924   }
71925   {
71926     try {
71927       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71928     } catch (std::out_of_range& e) {
71929       {
71930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71931       };
71932     } catch (std::exception& e) {
71933       {
71934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71935       };
71936     } catch (Dali::DaliException e) {
71937       {
71938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71939       };
71940     } catch (...) {
71941       {
71942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71943       };
71944     }
71945   }
71946
71947   jresult = (void *)result;
71948   return jresult;
71949 }
71950
71951
71952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71953   void * jresult ;
71954   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71955   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71956   Dali::Toolkit::FlexContainer *result = 0 ;
71957
71958   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71959   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71960   if (!arg2) {
71961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71962     return 0;
71963   }
71964   {
71965     try {
71966       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71967     } catch (std::out_of_range& e) {
71968       {
71969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71970       };
71971     } catch (std::exception& e) {
71972       {
71973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71974       };
71975     } catch (Dali::DaliException e) {
71976       {
71977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71978       };
71979     } catch (...) {
71980       {
71981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71982       };
71983     }
71984   }
71985
71986   jresult = (void *)result;
71987   return jresult;
71988 }
71989
71990
71991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71992   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71993
71994   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71995   {
71996     try {
71997       delete arg1;
71998     } catch (std::out_of_range& e) {
71999       {
72000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72001       };
72002     } catch (std::exception& e) {
72003       {
72004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72005       };
72006     } catch (Dali::DaliException e) {
72007       {
72008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72009       };
72010     } catch (...) {
72011       {
72012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72013       };
72014     }
72015   }
72016
72017 }
72018
72019
72020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72021   void * jresult ;
72022   Dali::Toolkit::FlexContainer result;
72023
72024   {
72025     try {
72026       result = Dali::Toolkit::FlexContainer::New();
72027     } catch (std::out_of_range& e) {
72028       {
72029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72030       };
72031     } catch (std::exception& e) {
72032       {
72033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72034       };
72035     } catch (Dali::DaliException e) {
72036       {
72037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72038       };
72039     } catch (...) {
72040       {
72041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72042       };
72043     }
72044   }
72045
72046   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72047   return jresult;
72048 }
72049
72050
72051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72052   void * jresult ;
72053   Dali::BaseHandle arg1 ;
72054   Dali::BaseHandle *argp1 ;
72055   Dali::Toolkit::FlexContainer result;
72056
72057   argp1 = (Dali::BaseHandle *)jarg1;
72058   if (!argp1) {
72059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72060     return 0;
72061   }
72062   arg1 = *argp1;
72063   {
72064     try {
72065       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72066     } catch (std::out_of_range& e) {
72067       {
72068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72069       };
72070     } catch (std::exception& e) {
72071       {
72072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72073       };
72074     } catch (Dali::DaliException e) {
72075       {
72076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72077       };
72078     } catch (...) {
72079       {
72080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72081       };
72082     }
72083   }
72084
72085   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72086   return jresult;
72087 }
72088
72089
72090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72091   int jresult ;
72092   int result;
72093
72094   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72095   jresult = (int)result;
72096   return jresult;
72097 }
72098
72099
72100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72101   int jresult ;
72102   int result;
72103
72104   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72105   jresult = (int)result;
72106   return jresult;
72107 }
72108
72109
72110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72111   int jresult ;
72112   int result;
72113
72114   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72115   jresult = (int)result;
72116   return jresult;
72117 }
72118
72119
72120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72121   int jresult ;
72122   int result;
72123
72124   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72125   jresult = (int)result;
72126   return jresult;
72127 }
72128
72129
72130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72131   void * jresult ;
72132   Dali::Toolkit::ImageView::Property *result = 0 ;
72133
72134   {
72135     try {
72136       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72137     } catch (std::out_of_range& e) {
72138       {
72139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72140       };
72141     } catch (std::exception& e) {
72142       {
72143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72144       };
72145     } catch (Dali::DaliException e) {
72146       {
72147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72148       };
72149     } catch (...) {
72150       {
72151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72152       };
72153     }
72154   }
72155
72156   jresult = (void *)result;
72157   return jresult;
72158 }
72159
72160
72161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72162   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72163
72164   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72165   {
72166     try {
72167       delete arg1;
72168     } catch (std::out_of_range& e) {
72169       {
72170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72171       };
72172     } catch (std::exception& e) {
72173       {
72174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72175       };
72176     } catch (Dali::DaliException e) {
72177       {
72178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72179       };
72180     } catch (...) {
72181       {
72182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72183       };
72184     }
72185   }
72186
72187 }
72188
72189
72190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72191   void * jresult ;
72192   Dali::Toolkit::ImageView *result = 0 ;
72193
72194   {
72195     try {
72196       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72197     } catch (std::out_of_range& e) {
72198       {
72199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72200       };
72201     } catch (std::exception& e) {
72202       {
72203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72204       };
72205     } catch (Dali::DaliException e) {
72206       {
72207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72208       };
72209     } catch (...) {
72210       {
72211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72212       };
72213     }
72214   }
72215
72216   jresult = (void *)result;
72217   return jresult;
72218 }
72219
72220
72221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72222   void * jresult ;
72223   Dali::Toolkit::ImageView result;
72224
72225   {
72226     try {
72227       result = Dali::Toolkit::ImageView::New();
72228     } catch (std::out_of_range& e) {
72229       {
72230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72231       };
72232     } catch (std::exception& e) {
72233       {
72234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72235       };
72236     } catch (Dali::DaliException e) {
72237       {
72238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72239       };
72240     } catch (...) {
72241       {
72242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72243       };
72244     }
72245   }
72246
72247   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72248   return jresult;
72249 }
72250
72251
72252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72253   void * jresult ;
72254   Dali::Image arg1 ;
72255   Dali::Image *argp1 ;
72256   Dali::Toolkit::ImageView result;
72257
72258   argp1 = (Dali::Image *)jarg1;
72259   if (!argp1) {
72260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72261     return 0;
72262   }
72263   arg1 = *argp1;
72264   {
72265     try {
72266       result = Dali::Toolkit::ImageView::New(arg1);
72267     } catch (std::out_of_range& e) {
72268       {
72269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72270       };
72271     } catch (std::exception& e) {
72272       {
72273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72274       };
72275     } catch (Dali::DaliException e) {
72276       {
72277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72278       };
72279     } catch (...) {
72280       {
72281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72282       };
72283     }
72284   }
72285
72286   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72287   return jresult;
72288 }
72289
72290
72291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72292   void * jresult ;
72293   std::string *arg1 = 0 ;
72294   Dali::Toolkit::ImageView result;
72295
72296   if (!jarg1) {
72297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72298     return 0;
72299   }
72300   std::string arg1_str(jarg1);
72301   arg1 = &arg1_str;
72302   {
72303     try {
72304       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72305     } catch (std::out_of_range& e) {
72306       {
72307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72308       };
72309     } catch (std::exception& e) {
72310       {
72311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72312       };
72313     } catch (Dali::DaliException e) {
72314       {
72315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72316       };
72317     } catch (...) {
72318       {
72319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72320       };
72321     }
72322   }
72323
72324   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72325
72326   //argout typemap for const std::string&
72327
72328   return jresult;
72329 }
72330
72331
72332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72333   void * jresult ;
72334   std::string *arg1 = 0 ;
72335   Dali::ImageDimensions arg2 ;
72336   Dali::ImageDimensions *argp2 ;
72337   Dali::Toolkit::ImageView result;
72338
72339   if (!jarg1) {
72340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72341     return 0;
72342   }
72343   std::string arg1_str(jarg1);
72344   arg1 = &arg1_str;
72345   argp2 = (Dali::ImageDimensions *)jarg2;
72346   if (!argp2) {
72347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72348     return 0;
72349   }
72350   arg2 = *argp2;
72351   {
72352     try {
72353       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72354     } catch (std::out_of_range& e) {
72355       {
72356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72357       };
72358     } catch (std::exception& e) {
72359       {
72360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72361       };
72362     } catch (Dali::DaliException e) {
72363       {
72364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72365       };
72366     } catch (...) {
72367       {
72368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72369       };
72370     }
72371   }
72372
72373   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72374
72375   //argout typemap for const std::string&
72376
72377   return jresult;
72378 }
72379
72380
72381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72382   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72383
72384   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72385   {
72386     try {
72387       delete arg1;
72388     } catch (std::out_of_range& e) {
72389       {
72390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72391       };
72392     } catch (std::exception& e) {
72393       {
72394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72395       };
72396     } catch (Dali::DaliException e) {
72397       {
72398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72399       };
72400     } catch (...) {
72401       {
72402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72403       };
72404     }
72405   }
72406
72407 }
72408
72409
72410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72411   void * jresult ;
72412   Dali::Toolkit::ImageView *arg1 = 0 ;
72413   Dali::Toolkit::ImageView *result = 0 ;
72414
72415   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72416   if (!arg1) {
72417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72418     return 0;
72419   }
72420   {
72421     try {
72422       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72423     } catch (std::out_of_range& e) {
72424       {
72425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72426       };
72427     } catch (std::exception& e) {
72428       {
72429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72430       };
72431     } catch (Dali::DaliException e) {
72432       {
72433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72434       };
72435     } catch (...) {
72436       {
72437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72438       };
72439     }
72440   }
72441
72442   jresult = (void *)result;
72443   return jresult;
72444 }
72445
72446
72447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72448   void * jresult ;
72449   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72450   Dali::Toolkit::ImageView *arg2 = 0 ;
72451   Dali::Toolkit::ImageView *result = 0 ;
72452
72453   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72454   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72455   if (!arg2) {
72456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72457     return 0;
72458   }
72459   {
72460     try {
72461       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72462     } catch (std::out_of_range& e) {
72463       {
72464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72465       };
72466     } catch (std::exception& e) {
72467       {
72468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72469       };
72470     } catch (Dali::DaliException e) {
72471       {
72472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72473       };
72474     } catch (...) {
72475       {
72476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72477       };
72478     }
72479   }
72480
72481   jresult = (void *)result;
72482   return jresult;
72483 }
72484
72485
72486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72487   void * jresult ;
72488   Dali::BaseHandle arg1 ;
72489   Dali::BaseHandle *argp1 ;
72490   Dali::Toolkit::ImageView result;
72491
72492   argp1 = (Dali::BaseHandle *)jarg1;
72493   if (!argp1) {
72494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72495     return 0;
72496   }
72497   arg1 = *argp1;
72498   {
72499     try {
72500       result = Dali::Toolkit::ImageView::DownCast(arg1);
72501     } catch (std::out_of_range& e) {
72502       {
72503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72504       };
72505     } catch (std::exception& e) {
72506       {
72507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72508       };
72509     } catch (Dali::DaliException e) {
72510       {
72511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72512       };
72513     } catch (...) {
72514       {
72515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72516       };
72517     }
72518   }
72519
72520   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72521   return jresult;
72522 }
72523
72524
72525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72526   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72527   Dali::Image arg2 ;
72528   Dali::Image *argp2 ;
72529
72530   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72531   argp2 = (Dali::Image *)jarg2;
72532   if (!argp2) {
72533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72534     return ;
72535   }
72536   arg2 = *argp2;
72537   {
72538     try {
72539       (arg1)->SetImage(arg2);
72540     } catch (std::out_of_range& e) {
72541       {
72542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72543       };
72544     } catch (std::exception& e) {
72545       {
72546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72547       };
72548     } catch (Dali::DaliException e) {
72549       {
72550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72551       };
72552     } catch (...) {
72553       {
72554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72555       };
72556     }
72557   }
72558
72559 }
72560
72561
72562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72563   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72564   std::string *arg2 = 0 ;
72565
72566   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72567   if (!jarg2) {
72568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72569     return ;
72570   }
72571   std::string arg2_str(jarg2);
72572   arg2 = &arg2_str;
72573   {
72574     try {
72575       (arg1)->SetImage((std::string const &)*arg2);
72576     } catch (std::out_of_range& e) {
72577       {
72578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72579       };
72580     } catch (std::exception& e) {
72581       {
72582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72583       };
72584     } catch (Dali::DaliException e) {
72585       {
72586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72587       };
72588     } catch (...) {
72589       {
72590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72591       };
72592     }
72593   }
72594
72595
72596   //argout typemap for const std::string&
72597
72598 }
72599
72600
72601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72602   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72603   std::string *arg2 = 0 ;
72604   Dali::ImageDimensions arg3 ;
72605   Dali::ImageDimensions *argp3 ;
72606
72607   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72608   if (!jarg2) {
72609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72610     return ;
72611   }
72612   std::string arg2_str(jarg2);
72613   arg2 = &arg2_str;
72614   argp3 = (Dali::ImageDimensions *)jarg3;
72615   if (!argp3) {
72616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72617     return ;
72618   }
72619   arg3 = *argp3;
72620   {
72621     try {
72622       (arg1)->SetImage((std::string const &)*arg2,arg3);
72623     } catch (std::out_of_range& e) {
72624       {
72625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72626       };
72627     } catch (std::exception& e) {
72628       {
72629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72630       };
72631     } catch (Dali::DaliException e) {
72632       {
72633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72634       };
72635     } catch (...) {
72636       {
72637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72638       };
72639     }
72640   }
72641
72642
72643   //argout typemap for const std::string&
72644
72645 }
72646
72647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72648   void * jresult ;
72649   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72650   Dali::Image result;
72651
72652   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72653   {
72654     try {
72655       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72656     } catch (std::out_of_range& e) {
72657       {
72658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72659       };
72660     } catch (std::exception& e) {
72661       {
72662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72663       };
72664     } catch (Dali::DaliException e) {
72665       {
72666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72667       };
72668     } catch (...) {
72669       {
72670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72671       };
72672     }
72673   }
72674
72675   jresult = new Dali::Image((const Dali::Image &)result);
72676   return jresult;
72677 }
72678
72679
72680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72681   int jresult ;
72682   int result;
72683
72684   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72685   jresult = (int)result;
72686   return jresult;
72687 }
72688
72689
72690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72691   int jresult ;
72692   int result;
72693
72694   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72695   jresult = (int)result;
72696   return jresult;
72697 }
72698
72699
72700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72701   int jresult ;
72702   int result;
72703
72704   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72705   jresult = (int)result;
72706   return jresult;
72707 }
72708
72709
72710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72711   int jresult ;
72712   int result;
72713
72714   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72715   jresult = (int)result;
72716   return jresult;
72717 }
72718
72719
72720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72721   int jresult ;
72722   int result;
72723
72724   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72725   jresult = (int)result;
72726   return jresult;
72727 }
72728
72729
72730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72731   int jresult ;
72732   int result;
72733
72734   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72735   jresult = (int)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72741   int jresult ;
72742   int result;
72743
72744   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72745   jresult = (int)result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72751   int jresult ;
72752   int result;
72753
72754   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72755   jresult = (int)result;
72756   return jresult;
72757 }
72758
72759
72760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72761   void * jresult ;
72762   Dali::Toolkit::Model3dView::Property *result = 0 ;
72763
72764   {
72765     try {
72766       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
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_delete_Model3dView_Property(void * jarg1) {
72792   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72793
72794   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72795   {
72796     try {
72797       delete arg1;
72798     } catch (std::out_of_range& e) {
72799       {
72800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72801       };
72802     } catch (std::exception& e) {
72803       {
72804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72805       };
72806     } catch (Dali::DaliException e) {
72807       {
72808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72809       };
72810     } catch (...) {
72811       {
72812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72813       };
72814     }
72815   }
72816
72817 }
72818
72819
72820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72821   void * jresult ;
72822   Dali::Toolkit::Model3dView result;
72823
72824   {
72825     try {
72826       result = Dali::Toolkit::Model3dView::New();
72827     } catch (std::out_of_range& e) {
72828       {
72829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72830       };
72831     } catch (std::exception& e) {
72832       {
72833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72834       };
72835     } catch (Dali::DaliException e) {
72836       {
72837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72838       };
72839     } catch (...) {
72840       {
72841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72842       };
72843     }
72844   }
72845
72846   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72847   return jresult;
72848 }
72849
72850
72851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72852   void * jresult ;
72853   std::string *arg1 = 0 ;
72854   std::string *arg2 = 0 ;
72855   std::string *arg3 = 0 ;
72856   Dali::Toolkit::Model3dView result;
72857
72858   if (!jarg1) {
72859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72860     return 0;
72861   }
72862   std::string arg1_str(jarg1);
72863   arg1 = &arg1_str;
72864   if (!jarg2) {
72865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72866     return 0;
72867   }
72868   std::string arg2_str(jarg2);
72869   arg2 = &arg2_str;
72870   if (!jarg3) {
72871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72872     return 0;
72873   }
72874   std::string arg3_str(jarg3);
72875   arg3 = &arg3_str;
72876   {
72877     try {
72878       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72879     } catch (std::out_of_range& e) {
72880       {
72881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72882       };
72883     } catch (std::exception& e) {
72884       {
72885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72886       };
72887     } catch (Dali::DaliException e) {
72888       {
72889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72890       };
72891     } catch (...) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72894       };
72895     }
72896   }
72897
72898   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72899
72900   //argout typemap for const std::string&
72901
72902
72903   //argout typemap for const std::string&
72904
72905
72906   //argout typemap for const std::string&
72907
72908   return jresult;
72909 }
72910
72911
72912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72913   void * jresult ;
72914   Dali::Toolkit::Model3dView *result = 0 ;
72915
72916   {
72917     try {
72918       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72919     } catch (std::out_of_range& e) {
72920       {
72921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72922       };
72923     } catch (std::exception& e) {
72924       {
72925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72926       };
72927     } catch (Dali::DaliException e) {
72928       {
72929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72930       };
72931     } catch (...) {
72932       {
72933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72934       };
72935     }
72936   }
72937
72938   jresult = (void *)result;
72939   return jresult;
72940 }
72941
72942
72943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72944   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72945
72946   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72947   {
72948     try {
72949       delete arg1;
72950     } catch (std::out_of_range& e) {
72951       {
72952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72953       };
72954     } catch (std::exception& e) {
72955       {
72956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72957       };
72958     } catch (Dali::DaliException e) {
72959       {
72960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72961       };
72962     } catch (...) {
72963       {
72964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72965       };
72966     }
72967   }
72968
72969 }
72970
72971
72972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72973   void * jresult ;
72974   Dali::Toolkit::Model3dView *arg1 = 0 ;
72975   Dali::Toolkit::Model3dView *result = 0 ;
72976
72977   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72978   if (!arg1) {
72979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72980     return 0;
72981   }
72982   {
72983     try {
72984       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72985     } catch (std::out_of_range& e) {
72986       {
72987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72988       };
72989     } catch (std::exception& e) {
72990       {
72991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72992       };
72993     } catch (Dali::DaliException e) {
72994       {
72995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72996       };
72997     } catch (...) {
72998       {
72999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73000       };
73001     }
73002   }
73003
73004   jresult = (void *)result;
73005   return jresult;
73006 }
73007
73008
73009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73010   void * jresult ;
73011   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73012   Dali::Toolkit::Model3dView *arg2 = 0 ;
73013   Dali::Toolkit::Model3dView *result = 0 ;
73014
73015   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73016   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73017   if (!arg2) {
73018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73019     return 0;
73020   }
73021   {
73022     try {
73023       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
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_Model3dView_DownCast(void * jarg1) {
73049   void * jresult ;
73050   Dali::BaseHandle arg1 ;
73051   Dali::BaseHandle *argp1 ;
73052   Dali::Toolkit::Model3dView result;
73053
73054   argp1 = (Dali::BaseHandle *)jarg1;
73055   if (!argp1) {
73056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73057     return 0;
73058   }
73059   arg1 = *argp1;
73060   {
73061     try {
73062       result = Dali::Toolkit::Model3dView::DownCast(arg1);
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 = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73083   return jresult;
73084 }
73085
73086
73087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73088   int jresult ;
73089   int result;
73090
73091   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73092   jresult = (int)result;
73093   return jresult;
73094 }
73095
73096
73097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73098   int jresult ;
73099   int result;
73100
73101   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73102   jresult = (int)result;
73103   return jresult;
73104 }
73105
73106
73107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73108   int jresult ;
73109   int result;
73110
73111   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73112   jresult = (int)result;
73113   return jresult;
73114 }
73115
73116
73117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73118   int jresult ;
73119   int result;
73120
73121   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73122   jresult = (int)result;
73123   return jresult;
73124 }
73125
73126
73127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73128   int jresult ;
73129   int result;
73130
73131   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73132   jresult = (int)result;
73133   return jresult;
73134 }
73135
73136
73137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73138   int jresult ;
73139   int result;
73140
73141   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73142   jresult = (int)result;
73143   return jresult;
73144 }
73145
73146
73147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73148   int jresult ;
73149   int result;
73150
73151   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73152   jresult = (int)result;
73153   return jresult;
73154 }
73155
73156
73157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73158   int jresult ;
73159   int result;
73160
73161   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73162   jresult = (int)result;
73163   return jresult;
73164 }
73165
73166
73167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73168   int jresult ;
73169   int result;
73170
73171   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73172   jresult = (int)result;
73173   return jresult;
73174 }
73175
73176
73177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73178   void * jresult ;
73179   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73180
73181   {
73182     try {
73183       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73184     } catch (std::out_of_range& e) {
73185       {
73186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73187       };
73188     } catch (std::exception& e) {
73189       {
73190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73191       };
73192     } catch (Dali::DaliException e) {
73193       {
73194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73195       };
73196     } catch (...) {
73197       {
73198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73199       };
73200     }
73201   }
73202
73203   jresult = (void *)result;
73204   return jresult;
73205 }
73206
73207
73208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73209   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73210
73211   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73212   {
73213     try {
73214       delete arg1;
73215     } catch (std::out_of_range& e) {
73216       {
73217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73218       };
73219     } catch (std::exception& e) {
73220       {
73221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73222       };
73223     } catch (Dali::DaliException e) {
73224       {
73225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73226       };
73227     } catch (...) {
73228       {
73229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73230       };
73231     }
73232   }
73233
73234 }
73235
73236
73237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73238   void * jresult ;
73239   Dali::Toolkit::ScrollBar *result = 0 ;
73240
73241   {
73242     try {
73243       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73244     } catch (std::out_of_range& e) {
73245       {
73246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73247       };
73248     } catch (std::exception& e) {
73249       {
73250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73251       };
73252     } catch (Dali::DaliException e) {
73253       {
73254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73255       };
73256     } catch (...) {
73257       {
73258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73259       };
73260     }
73261   }
73262
73263   jresult = (void *)result;
73264   return jresult;
73265 }
73266
73267
73268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73269   void * jresult ;
73270   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73271   Dali::Toolkit::ScrollBar *result = 0 ;
73272
73273   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73274   if (!arg1) {
73275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73276     return 0;
73277   }
73278   {
73279     try {
73280       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73281     } catch (std::out_of_range& e) {
73282       {
73283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73284       };
73285     } catch (std::exception& e) {
73286       {
73287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73288       };
73289     } catch (Dali::DaliException e) {
73290       {
73291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73292       };
73293     } catch (...) {
73294       {
73295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73296       };
73297     }
73298   }
73299
73300   jresult = (void *)result;
73301   return jresult;
73302 }
73303
73304
73305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73306   void * jresult ;
73307   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73308   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73309   Dali::Toolkit::ScrollBar *result = 0 ;
73310
73311   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73312   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73313   if (!arg2) {
73314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73315     return 0;
73316   }
73317   {
73318     try {
73319       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73320     } catch (std::out_of_range& e) {
73321       {
73322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73323       };
73324     } catch (std::exception& e) {
73325       {
73326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73327       };
73328     } catch (Dali::DaliException e) {
73329       {
73330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73331       };
73332     } catch (...) {
73333       {
73334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73335       };
73336     }
73337   }
73338
73339   jresult = (void *)result;
73340   return jresult;
73341 }
73342
73343
73344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73345   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73346
73347   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73348   {
73349     try {
73350       delete arg1;
73351     } catch (std::out_of_range& e) {
73352       {
73353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73354       };
73355     } catch (std::exception& e) {
73356       {
73357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73358       };
73359     } catch (Dali::DaliException e) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73362       };
73363     } catch (...) {
73364       {
73365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73366       };
73367     }
73368   }
73369
73370 }
73371
73372
73373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73374   void * jresult ;
73375   Dali::Toolkit::ScrollBar::Direction arg1 ;
73376   Dali::Toolkit::ScrollBar result;
73377
73378   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73379   {
73380     try {
73381       result = Dali::Toolkit::ScrollBar::New(arg1);
73382     } catch (std::out_of_range& e) {
73383       {
73384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73385       };
73386     } catch (std::exception& e) {
73387       {
73388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (Dali::DaliException e) {
73391       {
73392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73393       };
73394     } catch (...) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73397       };
73398     }
73399   }
73400
73401   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73402   return jresult;
73403 }
73404
73405
73406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73407   void * jresult ;
73408   Dali::Toolkit::ScrollBar result;
73409
73410   {
73411     try {
73412       result = Dali::Toolkit::ScrollBar::New();
73413     } catch (std::out_of_range& e) {
73414       {
73415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73416       };
73417     } catch (std::exception& e) {
73418       {
73419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73420       };
73421     } catch (Dali::DaliException e) {
73422       {
73423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73424       };
73425     } catch (...) {
73426       {
73427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73428       };
73429     }
73430   }
73431
73432   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73433   return jresult;
73434 }
73435
73436
73437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73438   void * jresult ;
73439   Dali::BaseHandle arg1 ;
73440   Dali::BaseHandle *argp1 ;
73441   Dali::Toolkit::ScrollBar result;
73442
73443   argp1 = (Dali::BaseHandle *)jarg1;
73444   if (!argp1) {
73445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73446     return 0;
73447   }
73448   arg1 = *argp1;
73449   {
73450     try {
73451       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73452     } catch (std::out_of_range& e) {
73453       {
73454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73455       };
73456     } catch (std::exception& e) {
73457       {
73458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73459       };
73460     } catch (Dali::DaliException e) {
73461       {
73462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73463       };
73464     } catch (...) {
73465       {
73466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73467       };
73468     }
73469   }
73470
73471   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73472   return jresult;
73473 }
73474
73475
73476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73477   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73478   Dali::Handle arg2 ;
73479   Dali::Property::Index arg3 ;
73480   Dali::Property::Index arg4 ;
73481   Dali::Property::Index arg5 ;
73482   Dali::Property::Index arg6 ;
73483   Dali::Handle *argp2 ;
73484
73485   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73486   argp2 = (Dali::Handle *)jarg2;
73487   if (!argp2) {
73488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73489     return ;
73490   }
73491   arg2 = *argp2;
73492   arg3 = (Dali::Property::Index)jarg3;
73493   arg4 = (Dali::Property::Index)jarg4;
73494   arg5 = (Dali::Property::Index)jarg5;
73495   arg6 = (Dali::Property::Index)jarg6;
73496   {
73497     try {
73498       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73499     } catch (std::out_of_range& e) {
73500       {
73501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73502       };
73503     } catch (std::exception& e) {
73504       {
73505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73506       };
73507     } catch (Dali::DaliException e) {
73508       {
73509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73510       };
73511     } catch (...) {
73512       {
73513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73514       };
73515     }
73516   }
73517
73518 }
73519
73520
73521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73522   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73523   Dali::Actor arg2 ;
73524   Dali::Actor *argp2 ;
73525
73526   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73527   argp2 = (Dali::Actor *)jarg2;
73528   if (!argp2) {
73529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73530     return ;
73531   }
73532   arg2 = *argp2;
73533   {
73534     try {
73535       (arg1)->SetScrollIndicator(arg2);
73536     } catch (std::out_of_range& e) {
73537       {
73538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73539       };
73540     } catch (std::exception& e) {
73541       {
73542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73543       };
73544     } catch (Dali::DaliException e) {
73545       {
73546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73547       };
73548     } catch (...) {
73549       {
73550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73551       };
73552     }
73553   }
73554
73555 }
73556
73557
73558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73559   void * jresult ;
73560   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73561   Dali::Actor result;
73562
73563   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73564   {
73565     try {
73566       result = (arg1)->GetScrollIndicator();
73567     } catch (std::out_of_range& e) {
73568       {
73569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73570       };
73571     } catch (std::exception& e) {
73572       {
73573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73574       };
73575     } catch (Dali::DaliException e) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73578       };
73579     } catch (...) {
73580       {
73581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73582       };
73583     }
73584   }
73585
73586   jresult = new Dali::Actor((const Dali::Actor &)result);
73587   return jresult;
73588 }
73589
73590
73591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73592   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73593   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73594
73595   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73596   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73597   if (!arg2) {
73598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73599     return ;
73600   }
73601   {
73602     try {
73603       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73604     } catch (std::out_of_range& e) {
73605       {
73606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73607       };
73608     } catch (std::exception& e) {
73609       {
73610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73611       };
73612     } catch (Dali::DaliException e) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73615       };
73616     } catch (...) {
73617       {
73618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73619       };
73620     }
73621   }
73622
73623 }
73624
73625
73626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73627   void * jresult ;
73628   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73629
73630   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73631   {
73632     try {
73633       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()));
73634     } catch (std::out_of_range& e) {
73635       {
73636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73637       };
73638     } catch (std::exception& e) {
73639       {
73640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73641       };
73642     } catch (...) {
73643       {
73644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73645       };
73646     }
73647   }
73648   return jresult;
73649 }
73650
73651
73652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73653   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73654   Dali::Toolkit::ScrollBar::Direction arg2 ;
73655
73656   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73657   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73658   {
73659     try {
73660       (arg1)->SetScrollDirection(arg2);
73661     } catch (std::out_of_range& e) {
73662       {
73663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73664       };
73665     } catch (std::exception& e) {
73666       {
73667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73668       };
73669     } catch (Dali::DaliException e) {
73670       {
73671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73672       };
73673     } catch (...) {
73674       {
73675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73676       };
73677     }
73678   }
73679
73680 }
73681
73682
73683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73684   int jresult ;
73685   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73686   Dali::Toolkit::ScrollBar::Direction result;
73687
73688   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73689   {
73690     try {
73691       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73692     } catch (std::out_of_range& e) {
73693       {
73694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73695       };
73696     } catch (std::exception& e) {
73697       {
73698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73699       };
73700     } catch (Dali::DaliException e) {
73701       {
73702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73703       };
73704     } catch (...) {
73705       {
73706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73707       };
73708     }
73709   }
73710
73711   jresult = (int)result;
73712   return jresult;
73713 }
73714
73715
73716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73717   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73718   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73719
73720   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73721   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73722   {
73723     try {
73724       (arg1)->SetIndicatorHeightPolicy(arg2);
73725     } catch (std::out_of_range& e) {
73726       {
73727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73728       };
73729     } catch (std::exception& e) {
73730       {
73731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73732       };
73733     } catch (Dali::DaliException e) {
73734       {
73735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73736       };
73737     } catch (...) {
73738       {
73739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73740       };
73741     }
73742   }
73743
73744 }
73745
73746
73747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73748   int jresult ;
73749   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73750   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73751
73752   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73753   {
73754     try {
73755       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73756     } catch (std::out_of_range& e) {
73757       {
73758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73759       };
73760     } catch (std::exception& e) {
73761       {
73762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73763       };
73764     } catch (Dali::DaliException e) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73767       };
73768     } catch (...) {
73769       {
73770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73771       };
73772     }
73773   }
73774
73775   jresult = (int)result;
73776   return jresult;
73777 }
73778
73779
73780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73781   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73782   float arg2 ;
73783
73784   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73785   arg2 = (float)jarg2;
73786   {
73787     try {
73788       (arg1)->SetIndicatorFixedHeight(arg2);
73789     } catch (std::out_of_range& e) {
73790       {
73791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73792       };
73793     } catch (std::exception& e) {
73794       {
73795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73796       };
73797     } catch (Dali::DaliException e) {
73798       {
73799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73800       };
73801     } catch (...) {
73802       {
73803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73804       };
73805     }
73806   }
73807
73808 }
73809
73810
73811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73812   float jresult ;
73813   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73814   float result;
73815
73816   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73817   {
73818     try {
73819       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73820     } catch (std::out_of_range& e) {
73821       {
73822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73823       };
73824     } catch (std::exception& e) {
73825       {
73826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73827       };
73828     } catch (Dali::DaliException e) {
73829       {
73830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73831       };
73832     } catch (...) {
73833       {
73834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73835       };
73836     }
73837   }
73838
73839   jresult = result;
73840   return jresult;
73841 }
73842
73843
73844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73845   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73846   float arg2 ;
73847
73848   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73849   arg2 = (float)jarg2;
73850   {
73851     try {
73852       (arg1)->SetIndicatorShowDuration(arg2);
73853     } catch (std::out_of_range& e) {
73854       {
73855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73856       };
73857     } catch (std::exception& e) {
73858       {
73859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73860       };
73861     } catch (Dali::DaliException e) {
73862       {
73863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73864       };
73865     } catch (...) {
73866       {
73867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73868       };
73869     }
73870   }
73871
73872 }
73873
73874
73875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73876   float jresult ;
73877   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73878   float result;
73879
73880   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73881   {
73882     try {
73883       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73884     } catch (std::out_of_range& e) {
73885       {
73886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73887       };
73888     } catch (std::exception& e) {
73889       {
73890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73891       };
73892     } catch (Dali::DaliException e) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73895       };
73896     } catch (...) {
73897       {
73898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73899       };
73900     }
73901   }
73902
73903   jresult = result;
73904   return jresult;
73905 }
73906
73907
73908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73909   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73910   float arg2 ;
73911
73912   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73913   arg2 = (float)jarg2;
73914   {
73915     try {
73916       (arg1)->SetIndicatorHideDuration(arg2);
73917     } catch (std::out_of_range& e) {
73918       {
73919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73920       };
73921     } catch (std::exception& e) {
73922       {
73923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73924       };
73925     } catch (Dali::DaliException e) {
73926       {
73927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73928       };
73929     } catch (...) {
73930       {
73931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73932       };
73933     }
73934   }
73935
73936 }
73937
73938
73939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73940   float jresult ;
73941   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73942   float result;
73943
73944   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73945   {
73946     try {
73947       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73948     } catch (std::out_of_range& e) {
73949       {
73950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73951       };
73952     } catch (std::exception& e) {
73953       {
73954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73955       };
73956     } catch (Dali::DaliException e) {
73957       {
73958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73959       };
73960     } catch (...) {
73961       {
73962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73963       };
73964     }
73965   }
73966
73967   jresult = result;
73968   return jresult;
73969 }
73970
73971
73972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73973   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73974
73975   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73976   {
73977     try {
73978       (arg1)->ShowIndicator();
73979     } catch (std::out_of_range& e) {
73980       {
73981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73982       };
73983     } catch (std::exception& e) {
73984       {
73985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73986       };
73987     } catch (Dali::DaliException e) {
73988       {
73989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73990       };
73991     } catch (...) {
73992       {
73993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73994       };
73995     }
73996   }
73997
73998 }
73999
74000
74001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74002   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74003
74004   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74005   {
74006     try {
74007       (arg1)->HideIndicator();
74008     } catch (std::out_of_range& e) {
74009       {
74010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74011       };
74012     } catch (std::exception& e) {
74013       {
74014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74015       };
74016     } catch (Dali::DaliException e) {
74017       {
74018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74019       };
74020     } catch (...) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74023       };
74024     }
74025   }
74026
74027 }
74028
74029
74030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74031   void * jresult ;
74032   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74033   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74034
74035   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74036   {
74037     try {
74038       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74039     } catch (std::out_of_range& e) {
74040       {
74041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74042       };
74043     } catch (std::exception& e) {
74044       {
74045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74046       };
74047     } catch (Dali::DaliException e) {
74048       {
74049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74050       };
74051     } catch (...) {
74052       {
74053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74054       };
74055     }
74056   }
74057
74058   jresult = (void *)result;
74059   return jresult;
74060 }
74061
74062
74063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74064   void * jresult ;
74065   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74066   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74067
74068   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74069   {
74070     try {
74071       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74072     } catch (std::out_of_range& e) {
74073       {
74074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74075       };
74076     } catch (std::exception& e) {
74077       {
74078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74079       };
74080     } catch (Dali::DaliException e) {
74081       {
74082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74083       };
74084     } catch (...) {
74085       {
74086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74087       };
74088     }
74089   }
74090
74091   jresult = (void *)result;
74092   return jresult;
74093 }
74094
74095
74096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74097   int jresult ;
74098   int result;
74099
74100   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74101   jresult = (int)result;
74102   return jresult;
74103 }
74104
74105
74106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74107   int jresult ;
74108   int result;
74109
74110   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74111   jresult = (int)result;
74112   return jresult;
74113 }
74114
74115
74116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74117   int jresult ;
74118   int result;
74119
74120   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74121   jresult = (int)result;
74122   return jresult;
74123 }
74124
74125
74126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74127   int jresult ;
74128   int result;
74129
74130   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74131   jresult = (int)result;
74132   return jresult;
74133 }
74134
74135
74136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74137   int jresult ;
74138   int result;
74139
74140   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74141   jresult = (int)result;
74142   return jresult;
74143 }
74144
74145
74146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74147   int jresult ;
74148   int result;
74149
74150   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74151   jresult = (int)result;
74152   return jresult;
74153 }
74154
74155
74156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74157   int jresult ;
74158   int result;
74159
74160   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74161   jresult = (int)result;
74162   return jresult;
74163 }
74164
74165
74166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74167   int jresult ;
74168   int result;
74169
74170   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74171   jresult = (int)result;
74172   return jresult;
74173 }
74174
74175
74176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74177   int jresult ;
74178   int result;
74179
74180   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74181   jresult = (int)result;
74182   return jresult;
74183 }
74184
74185
74186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74187   int jresult ;
74188   int result;
74189
74190   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74191   jresult = (int)result;
74192   return jresult;
74193 }
74194
74195
74196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74197   int jresult ;
74198   int result;
74199
74200   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74201   jresult = (int)result;
74202   return jresult;
74203 }
74204
74205
74206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74207   int jresult ;
74208   int result;
74209
74210   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74211   jresult = (int)result;
74212   return jresult;
74213 }
74214
74215
74216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74217   int jresult ;
74218   int result;
74219
74220   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74221   jresult = (int)result;
74222   return jresult;
74223 }
74224
74225
74226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74227   int jresult ;
74228   int result;
74229
74230   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74231   jresult = (int)result;
74232   return jresult;
74233 }
74234
74235
74236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74237   void * jresult ;
74238   Dali::Toolkit::Scrollable::Property *result = 0 ;
74239
74240   {
74241     try {
74242       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74243     } catch (std::out_of_range& e) {
74244       {
74245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74246       };
74247     } catch (std::exception& e) {
74248       {
74249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74250       };
74251     } catch (Dali::DaliException e) {
74252       {
74253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74254       };
74255     } catch (...) {
74256       {
74257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74258       };
74259     }
74260   }
74261
74262   jresult = (void *)result;
74263   return jresult;
74264 }
74265
74266
74267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74268   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74269
74270   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74271   {
74272     try {
74273       delete arg1;
74274     } catch (std::out_of_range& e) {
74275       {
74276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74277       };
74278     } catch (std::exception& e) {
74279       {
74280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74281       };
74282     } catch (Dali::DaliException e) {
74283       {
74284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74285       };
74286     } catch (...) {
74287       {
74288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74289       };
74290     }
74291   }
74292
74293 }
74294
74295
74296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74297   void * jresult ;
74298   Dali::Toolkit::Scrollable *result = 0 ;
74299
74300   {
74301     try {
74302       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74303     } catch (std::out_of_range& e) {
74304       {
74305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74306       };
74307     } catch (std::exception& e) {
74308       {
74309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74310       };
74311     } catch (Dali::DaliException e) {
74312       {
74313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74314       };
74315     } catch (...) {
74316       {
74317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74318       };
74319     }
74320   }
74321
74322   jresult = (void *)result;
74323   return jresult;
74324 }
74325
74326
74327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74328   void * jresult ;
74329   Dali::Toolkit::Scrollable *arg1 = 0 ;
74330   Dali::Toolkit::Scrollable *result = 0 ;
74331
74332   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74333   if (!arg1) {
74334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74335     return 0;
74336   }
74337   {
74338     try {
74339       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74340     } catch (std::out_of_range& e) {
74341       {
74342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74343       };
74344     } catch (std::exception& e) {
74345       {
74346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74347       };
74348     } catch (Dali::DaliException e) {
74349       {
74350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74351       };
74352     } catch (...) {
74353       {
74354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74355       };
74356     }
74357   }
74358
74359   jresult = (void *)result;
74360   return jresult;
74361 }
74362
74363
74364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74365   void * jresult ;
74366   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74367   Dali::Toolkit::Scrollable *arg2 = 0 ;
74368   Dali::Toolkit::Scrollable *result = 0 ;
74369
74370   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74371   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74372   if (!arg2) {
74373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74374     return 0;
74375   }
74376   {
74377     try {
74378       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74379     } catch (std::out_of_range& e) {
74380       {
74381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74382       };
74383     } catch (std::exception& e) {
74384       {
74385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74386       };
74387     } catch (Dali::DaliException e) {
74388       {
74389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74390       };
74391     } catch (...) {
74392       {
74393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74394       };
74395     }
74396   }
74397
74398   jresult = (void *)result;
74399   return jresult;
74400 }
74401
74402
74403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74404   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74405
74406   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74407   {
74408     try {
74409       delete arg1;
74410     } catch (std::out_of_range& e) {
74411       {
74412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74413       };
74414     } catch (std::exception& e) {
74415       {
74416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74417       };
74418     } catch (Dali::DaliException e) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74421       };
74422     } catch (...) {
74423       {
74424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74425       };
74426     }
74427   }
74428
74429 }
74430
74431
74432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74433   void * jresult ;
74434   Dali::BaseHandle arg1 ;
74435   Dali::BaseHandle *argp1 ;
74436   Dali::Toolkit::Scrollable result;
74437
74438   argp1 = (Dali::BaseHandle *)jarg1;
74439   if (!argp1) {
74440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74441     return 0;
74442   }
74443   arg1 = *argp1;
74444   {
74445     try {
74446       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74447     } catch (std::out_of_range& e) {
74448       {
74449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74450       };
74451     } catch (std::exception& e) {
74452       {
74453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74454       };
74455     } catch (Dali::DaliException e) {
74456       {
74457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74458       };
74459     } catch (...) {
74460       {
74461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74462       };
74463     }
74464   }
74465
74466   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74467   return jresult;
74468 }
74469
74470
74471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74472   unsigned int jresult ;
74473   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74474   bool result;
74475
74476   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74477   {
74478     try {
74479       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74480     } catch (std::out_of_range& e) {
74481       {
74482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74483       };
74484     } catch (std::exception& e) {
74485       {
74486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74487       };
74488     } catch (Dali::DaliException e) {
74489       {
74490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74491       };
74492     } catch (...) {
74493       {
74494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74495       };
74496     }
74497   }
74498
74499   jresult = result;
74500   return jresult;
74501 }
74502
74503
74504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74505   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74506   bool arg2 ;
74507
74508   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74509   arg2 = jarg2 ? true : false;
74510   {
74511     try {
74512       (arg1)->SetOvershootEnabled(arg2);
74513     } catch (std::out_of_range& e) {
74514       {
74515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74516       };
74517     } catch (std::exception& e) {
74518       {
74519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74520       };
74521     } catch (Dali::DaliException e) {
74522       {
74523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74524       };
74525     } catch (...) {
74526       {
74527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74528       };
74529     }
74530   }
74531
74532 }
74533
74534
74535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74536   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74537   Dali::Vector4 *arg2 = 0 ;
74538
74539   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74540   arg2 = (Dali::Vector4 *)jarg2;
74541   if (!arg2) {
74542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74543     return ;
74544   }
74545   {
74546     try {
74547       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74548     } catch (std::out_of_range& e) {
74549       {
74550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74551       };
74552     } catch (std::exception& e) {
74553       {
74554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74555       };
74556     } catch (Dali::DaliException e) {
74557       {
74558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74559       };
74560     } catch (...) {
74561       {
74562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74563       };
74564     }
74565   }
74566
74567 }
74568
74569
74570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74571   void * jresult ;
74572   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74573   Dali::Vector4 result;
74574
74575   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74576   {
74577     try {
74578       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74579     } catch (std::out_of_range& e) {
74580       {
74581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74582       };
74583     } catch (std::exception& e) {
74584       {
74585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74586       };
74587     } catch (Dali::DaliException e) {
74588       {
74589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74590       };
74591     } catch (...) {
74592       {
74593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74594       };
74595     }
74596   }
74597
74598   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74599   return jresult;
74600 }
74601
74602
74603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74604   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74605   float arg2 ;
74606
74607   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74608   arg2 = (float)jarg2;
74609   {
74610     try {
74611       (arg1)->SetOvershootAnimationSpeed(arg2);
74612     } catch (std::out_of_range& e) {
74613       {
74614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74615       };
74616     } catch (std::exception& e) {
74617       {
74618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74619       };
74620     } catch (Dali::DaliException e) {
74621       {
74622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74623       };
74624     } catch (...) {
74625       {
74626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74627       };
74628     }
74629   }
74630
74631 }
74632
74633
74634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74635   float jresult ;
74636   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74637   float result;
74638
74639   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74640   {
74641     try {
74642       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74643     } catch (std::out_of_range& e) {
74644       {
74645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74646       };
74647     } catch (std::exception& e) {
74648       {
74649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74650       };
74651     } catch (Dali::DaliException e) {
74652       {
74653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74654       };
74655     } catch (...) {
74656       {
74657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74658       };
74659     }
74660   }
74661
74662   jresult = result;
74663   return jresult;
74664 }
74665
74666
74667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74668   void * jresult ;
74669   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74670   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74671
74672   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74673   {
74674     try {
74675       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74676     } catch (std::out_of_range& e) {
74677       {
74678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74679       };
74680     } catch (std::exception& e) {
74681       {
74682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74683       };
74684     } catch (Dali::DaliException e) {
74685       {
74686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74687       };
74688     } catch (...) {
74689       {
74690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74691       };
74692     }
74693   }
74694
74695   jresult = (void *)result;
74696   return jresult;
74697 }
74698
74699
74700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74701   void * jresult ;
74702   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74703   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74704
74705   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74706   {
74707     try {
74708       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74709     } catch (std::out_of_range& e) {
74710       {
74711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74712       };
74713     } catch (std::exception& e) {
74714       {
74715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74716       };
74717     } catch (Dali::DaliException e) {
74718       {
74719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74720       };
74721     } catch (...) {
74722       {
74723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74724       };
74725     }
74726   }
74727
74728   jresult = (void *)result;
74729   return jresult;
74730 }
74731
74732
74733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74734   void * jresult ;
74735   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74736   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74737
74738   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74739   {
74740     try {
74741       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74742     } catch (std::out_of_range& e) {
74743       {
74744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74745       };
74746     } catch (std::exception& e) {
74747       {
74748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74749       };
74750     } catch (Dali::DaliException e) {
74751       {
74752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74753       };
74754     } catch (...) {
74755       {
74756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74757       };
74758     }
74759   }
74760
74761   jresult = (void *)result;
74762   return jresult;
74763 }
74764
74765
74766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74767   unsigned int jresult ;
74768   Dali::Toolkit::ControlOrientation::Type arg1 ;
74769   bool result;
74770
74771   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74772   {
74773     try {
74774       result = (bool)Dali::Toolkit::IsVertical(arg1);
74775     } catch (std::out_of_range& e) {
74776       {
74777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74778       };
74779     } catch (std::exception& e) {
74780       {
74781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74782       };
74783     } catch (Dali::DaliException e) {
74784       {
74785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74786       };
74787     } catch (...) {
74788       {
74789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74790       };
74791     }
74792   }
74793
74794   jresult = result;
74795   return jresult;
74796 }
74797
74798
74799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74800   unsigned int jresult ;
74801   Dali::Toolkit::ControlOrientation::Type arg1 ;
74802   bool result;
74803
74804   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74805   {
74806     try {
74807       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74808     } catch (std::out_of_range& e) {
74809       {
74810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74811       };
74812     } catch (std::exception& e) {
74813       {
74814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74815       };
74816     } catch (Dali::DaliException e) {
74817       {
74818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74819       };
74820     } catch (...) {
74821       {
74822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74823       };
74824     }
74825   }
74826
74827   jresult = result;
74828   return jresult;
74829 }
74830
74831
74832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74833   void * jresult ;
74834   unsigned int arg1 ;
74835   unsigned int arg2 ;
74836   Dali::Toolkit::ItemRange *result = 0 ;
74837
74838   arg1 = (unsigned int)jarg1;
74839   arg2 = (unsigned int)jarg2;
74840   {
74841     try {
74842       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74843     } catch (std::out_of_range& e) {
74844       {
74845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74846       };
74847     } catch (std::exception& e) {
74848       {
74849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74850       };
74851     } catch (Dali::DaliException e) {
74852       {
74853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74854       };
74855     } catch (...) {
74856       {
74857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74858       };
74859     }
74860   }
74861
74862   jresult = (void *)result;
74863   return jresult;
74864 }
74865
74866
74867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74868   void * jresult ;
74869   Dali::Toolkit::ItemRange *arg1 = 0 ;
74870   Dali::Toolkit::ItemRange *result = 0 ;
74871
74872   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74873   if (!arg1) {
74874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74875     return 0;
74876   }
74877   {
74878     try {
74879       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74880     } catch (std::out_of_range& e) {
74881       {
74882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74883       };
74884     } catch (std::exception& e) {
74885       {
74886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74887       };
74888     } catch (Dali::DaliException e) {
74889       {
74890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74891       };
74892     } catch (...) {
74893       {
74894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74895       };
74896     }
74897   }
74898
74899   jresult = (void *)result;
74900   return jresult;
74901 }
74902
74903
74904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74905   void * jresult ;
74906   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74907   Dali::Toolkit::ItemRange *arg2 = 0 ;
74908   Dali::Toolkit::ItemRange *result = 0 ;
74909
74910   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74911   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74912   if (!arg2) {
74913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74914     return 0;
74915   }
74916   {
74917     try {
74918       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74919     } catch (std::out_of_range& e) {
74920       {
74921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74922       };
74923     } catch (std::exception& e) {
74924       {
74925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74926       };
74927     } catch (Dali::DaliException e) {
74928       {
74929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74930       };
74931     } catch (...) {
74932       {
74933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74934       };
74935     }
74936   }
74937
74938   jresult = (void *)result;
74939   return jresult;
74940 }
74941
74942
74943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74944   unsigned int jresult ;
74945   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74946   unsigned int arg2 ;
74947   bool result;
74948
74949   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74950   arg2 = (unsigned int)jarg2;
74951   {
74952     try {
74953       result = (bool)(arg1)->Within(arg2);
74954     } catch (std::out_of_range& e) {
74955       {
74956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74957       };
74958     } catch (std::exception& e) {
74959       {
74960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74961       };
74962     } catch (Dali::DaliException e) {
74963       {
74964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74965       };
74966     } catch (...) {
74967       {
74968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74969       };
74970     }
74971   }
74972
74973   jresult = result;
74974   return jresult;
74975 }
74976
74977
74978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74979   void * jresult ;
74980   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74981   Dali::Toolkit::ItemRange *arg2 = 0 ;
74982   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74983
74984   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74985   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74986   if (!arg2) {
74987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74988     return 0;
74989   }
74990   {
74991     try {
74992       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74993     } catch (std::out_of_range& e) {
74994       {
74995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74996       };
74997     } catch (std::exception& e) {
74998       {
74999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75000       };
75001     } catch (Dali::DaliException e) {
75002       {
75003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75004       };
75005     } catch (...) {
75006       {
75007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75008       };
75009     }
75010   }
75011
75012   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75013   return jresult;
75014 }
75015
75016
75017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75018   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75019   unsigned int arg2 ;
75020
75021   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75022   arg2 = (unsigned int)jarg2;
75023   if (arg1) (arg1)->begin = arg2;
75024 }
75025
75026
75027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75028   unsigned int jresult ;
75029   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75030   unsigned int result;
75031
75032   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75033   result = (unsigned int) ((arg1)->begin);
75034   jresult = result;
75035   return jresult;
75036 }
75037
75038
75039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75040   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75041   unsigned int arg2 ;
75042
75043   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75044   arg2 = (unsigned int)jarg2;
75045   if (arg1) (arg1)->end = arg2;
75046 }
75047
75048
75049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75050   unsigned int jresult ;
75051   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75052   unsigned int result;
75053
75054   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75055   result = (unsigned int) ((arg1)->end);
75056   jresult = result;
75057   return jresult;
75058 }
75059
75060
75061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75062   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75063
75064   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75065   {
75066     try {
75067       delete arg1;
75068     } catch (std::out_of_range& e) {
75069       {
75070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75071       };
75072     } catch (std::exception& e) {
75073       {
75074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75075       };
75076     } catch (Dali::DaliException e) {
75077       {
75078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75079       };
75080     } catch (...) {
75081       {
75082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75083       };
75084     }
75085   }
75086
75087 }
75088
75089
75090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75091   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75092
75093   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75094   {
75095     try {
75096       delete arg1;
75097     } catch (std::out_of_range& e) {
75098       {
75099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75100       };
75101     } catch (std::exception& e) {
75102       {
75103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75104       };
75105     } catch (Dali::DaliException e) {
75106       {
75107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75108       };
75109     } catch (...) {
75110       {
75111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75112       };
75113     }
75114   }
75115
75116 }
75117
75118
75119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75120   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75121   Dali::Toolkit::ControlOrientation::Type arg2 ;
75122
75123   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75124   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75125   {
75126     try {
75127       (arg1)->SetOrientation(arg2);
75128     } catch (std::out_of_range& e) {
75129       {
75130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75131       };
75132     } catch (std::exception& e) {
75133       {
75134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75135       };
75136     } catch (Dali::DaliException e) {
75137       {
75138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75139       };
75140     } catch (...) {
75141       {
75142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75143       };
75144     }
75145   }
75146
75147 }
75148
75149
75150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75151   int jresult ;
75152   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75153   Dali::Toolkit::ControlOrientation::Type result;
75154
75155   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75156   {
75157     try {
75158       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75159     } catch (std::out_of_range& e) {
75160       {
75161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75162       };
75163     } catch (std::exception& e) {
75164       {
75165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75166       };
75167     } catch (Dali::DaliException e) {
75168       {
75169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75170       };
75171     } catch (...) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75174       };
75175     }
75176   }
75177
75178   jresult = (int)result;
75179   return jresult;
75180 }
75181
75182
75183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75184   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75185   Dali::Property::Map *arg2 = 0 ;
75186
75187   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75188   arg2 = (Dali::Property::Map *)jarg2;
75189   if (!arg2) {
75190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75191     return ;
75192   }
75193   {
75194     try {
75195       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75196     } catch (std::out_of_range& e) {
75197       {
75198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75199       };
75200     } catch (std::exception& e) {
75201       {
75202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75203       };
75204     } catch (Dali::DaliException e) {
75205       {
75206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75207       };
75208     } catch (...) {
75209       {
75210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75211       };
75212     }
75213   }
75214
75215 }
75216
75217
75218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75219   void * jresult ;
75220   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75221   Dali::Property::Map result;
75222
75223   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75224   {
75225     try {
75226       result = (arg1)->GetLayoutProperties();
75227     } catch (std::out_of_range& e) {
75228       {
75229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75230       };
75231     } catch (std::exception& e) {
75232       {
75233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75234       };
75235     } catch (Dali::DaliException e) {
75236       {
75237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75238       };
75239     } catch (...) {
75240       {
75241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75242       };
75243     }
75244   }
75245
75246   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75247   return jresult;
75248 }
75249
75250
75251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75252   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75253   unsigned int arg2 ;
75254   Dali::Vector3 *arg3 = 0 ;
75255   Dali::Vector3 *arg4 = 0 ;
75256
75257   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75258   arg2 = (unsigned int)jarg2;
75259   arg3 = (Dali::Vector3 *)jarg3;
75260   if (!arg3) {
75261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75262     return ;
75263   }
75264   arg4 = (Dali::Vector3 *)jarg4;
75265   if (!arg4) {
75266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75267     return ;
75268   }
75269   {
75270     try {
75271       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75272     } catch (std::out_of_range& e) {
75273       {
75274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75275       };
75276     } catch (std::exception& e) {
75277       {
75278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75279       };
75280     } catch (Dali::DaliException e) {
75281       {
75282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75283       };
75284     } catch (...) {
75285       {
75286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75287       };
75288     }
75289   }
75290
75291 }
75292
75293
75294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75295   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75296   Dali::Vector3 *arg2 = 0 ;
75297
75298   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75299   arg2 = (Dali::Vector3 *)jarg2;
75300   if (!arg2) {
75301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75302     return ;
75303   }
75304   {
75305     try {
75306       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75307     } catch (std::out_of_range& e) {
75308       {
75309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75310       };
75311     } catch (std::exception& e) {
75312       {
75313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75314       };
75315     } catch (Dali::DaliException e) {
75316       {
75317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75318       };
75319     } catch (...) {
75320       {
75321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75322       };
75323     }
75324   }
75325
75326 }
75327
75328
75329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75330   float jresult ;
75331   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75332   unsigned int arg2 ;
75333   Dali::Vector3 arg3 ;
75334   Dali::Vector3 *argp3 ;
75335   float result;
75336
75337   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75338   arg2 = (unsigned int)jarg2;
75339   argp3 = (Dali::Vector3 *)jarg3;
75340   if (!argp3) {
75341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75342     return 0;
75343   }
75344   arg3 = *argp3;
75345   {
75346     try {
75347       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75348     } catch (std::out_of_range& e) {
75349       {
75350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75351       };
75352     } catch (std::exception& e) {
75353       {
75354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75355       };
75356     } catch (Dali::DaliException e) {
75357       {
75358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75359       };
75360     } catch (...) {
75361       {
75362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75363       };
75364     }
75365   }
75366
75367   jresult = result;
75368   return jresult;
75369 }
75370
75371
75372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75373   float jresult ;
75374   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75375   float arg2 ;
75376   float result;
75377
75378   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75379   arg2 = (float)jarg2;
75380   {
75381     try {
75382       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75383     } catch (std::out_of_range& e) {
75384       {
75385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75386       };
75387     } catch (std::exception& e) {
75388       {
75389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75390       };
75391     } catch (Dali::DaliException e) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75394       };
75395     } catch (...) {
75396       {
75397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75398       };
75399     }
75400   }
75401
75402   jresult = result;
75403   return jresult;
75404 }
75405
75406
75407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75408   float jresult ;
75409   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75410   unsigned int arg2 ;
75411   float result;
75412
75413   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75414   arg2 = (unsigned int)jarg2;
75415   {
75416     try {
75417       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75418     } catch (std::out_of_range& e) {
75419       {
75420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75421       };
75422     } catch (std::exception& e) {
75423       {
75424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75425       };
75426     } catch (Dali::DaliException e) {
75427       {
75428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75429       };
75430     } catch (...) {
75431       {
75432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75433       };
75434     }
75435   }
75436
75437   jresult = result;
75438   return jresult;
75439 }
75440
75441
75442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75443   void * jresult ;
75444   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75445   float arg2 ;
75446   Dali::Vector3 arg3 ;
75447   Dali::Vector3 *argp3 ;
75448   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75449
75450   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75451   arg2 = (float)jarg2;
75452   argp3 = (Dali::Vector3 *)jarg3;
75453   if (!argp3) {
75454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75455     return 0;
75456   }
75457   arg3 = *argp3;
75458   {
75459     try {
75460       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75468       };
75469     } catch (Dali::DaliException e) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75472       };
75473     } catch (...) {
75474       {
75475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75476       };
75477     }
75478   }
75479
75480   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75481   return jresult;
75482 }
75483
75484
75485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75486   float jresult ;
75487   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75488   int arg2 ;
75489   float arg3 ;
75490   Dali::Vector3 *arg4 = 0 ;
75491   float result;
75492
75493   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75494   arg2 = (int)jarg2;
75495   arg3 = (float)jarg3;
75496   arg4 = (Dali::Vector3 *)jarg4;
75497   if (!arg4) {
75498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75499     return 0;
75500   }
75501   {
75502     try {
75503       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
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 unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75529   unsigned int jresult ;
75530   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75531   Dali::Vector3 arg2 ;
75532   Dali::Vector3 *argp2 ;
75533   unsigned int result;
75534
75535   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75536   argp2 = (Dali::Vector3 *)jarg2;
75537   if (!argp2) {
75538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75539     return 0;
75540   }
75541   arg2 = *argp2;
75542   {
75543     try {
75544       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75545     } catch (std::out_of_range& e) {
75546       {
75547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75548       };
75549     } catch (std::exception& e) {
75550       {
75551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75552       };
75553     } catch (Dali::DaliException e) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75556       };
75557     } catch (...) {
75558       {
75559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75560       };
75561     }
75562   }
75563
75564   jresult = result;
75565   return jresult;
75566 }
75567
75568
75569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75570   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75571   unsigned int arg2 ;
75572   Dali::Vector3 *arg3 = 0 ;
75573   Dali::Vector3 *arg4 = 0 ;
75574
75575   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75576   arg2 = (unsigned int)jarg2;
75577   arg3 = (Dali::Vector3 *)jarg3;
75578   if (!arg3) {
75579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75580     return ;
75581   }
75582   arg4 = (Dali::Vector3 *)jarg4;
75583   if (!arg4) {
75584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75585     return ;
75586   }
75587   {
75588     try {
75589       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75590     } catch (std::out_of_range& e) {
75591       {
75592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75593       };
75594     } catch (std::exception& e) {
75595       {
75596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75597       };
75598     } catch (Dali::DaliException e) {
75599       {
75600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75601       };
75602     } catch (...) {
75603       {
75604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75605       };
75606     }
75607   }
75608
75609 }
75610
75611
75612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75613   void * jresult ;
75614   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75615   Dali::Degree result;
75616
75617   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75618   {
75619     try {
75620       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75621     } catch (std::out_of_range& e) {
75622       {
75623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75624       };
75625     } catch (std::exception& e) {
75626       {
75627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75628       };
75629     } catch (Dali::DaliException e) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75632       };
75633     } catch (...) {
75634       {
75635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75636       };
75637     }
75638   }
75639
75640   jresult = new Dali::Degree((const Dali::Degree &)result);
75641   return jresult;
75642 }
75643
75644
75645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75646   float jresult ;
75647   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75648   float result;
75649
75650   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75651   {
75652     try {
75653       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75654     } catch (std::out_of_range& e) {
75655       {
75656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75657       };
75658     } catch (std::exception& e) {
75659       {
75660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75661       };
75662     } catch (Dali::DaliException e) {
75663       {
75664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75665       };
75666     } catch (...) {
75667       {
75668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75669       };
75670     }
75671   }
75672
75673   jresult = result;
75674   return jresult;
75675 }
75676
75677
75678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75679   float jresult ;
75680   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75681   float result;
75682
75683   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75684   {
75685     try {
75686       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75687     } catch (std::out_of_range& e) {
75688       {
75689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75690       };
75691     } catch (std::exception& e) {
75692       {
75693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75694       };
75695     } catch (Dali::DaliException e) {
75696       {
75697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75698       };
75699     } catch (...) {
75700       {
75701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75702       };
75703     }
75704   }
75705
75706   jresult = result;
75707   return jresult;
75708 }
75709
75710
75711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75712   float jresult ;
75713   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75714   float result;
75715
75716   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75717   {
75718     try {
75719       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75720     } catch (std::out_of_range& e) {
75721       {
75722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75723       };
75724     } catch (std::exception& e) {
75725       {
75726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75727       };
75728     } catch (Dali::DaliException e) {
75729       {
75730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75731       };
75732     } catch (...) {
75733       {
75734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75735       };
75736     }
75737   }
75738
75739   jresult = result;
75740   return jresult;
75741 }
75742
75743
75744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75745   int jresult ;
75746   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75747   int arg2 ;
75748   int arg3 ;
75749   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75750   bool arg5 ;
75751   int result;
75752
75753   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75754   arg2 = (int)jarg2;
75755   arg3 = (int)jarg3;
75756   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75757   arg5 = jarg5 ? true : false;
75758   {
75759     try {
75760       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75761     } catch (std::out_of_range& e) {
75762       {
75763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75764       };
75765     } catch (std::exception& e) {
75766       {
75767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75768       };
75769     } catch (Dali::DaliException e) {
75770       {
75771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75772       };
75773     } catch (...) {
75774       {
75775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75776       };
75777     }
75778   }
75779
75780   jresult = result;
75781   return jresult;
75782 }
75783
75784
75785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75786   float jresult ;
75787   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75788   float result;
75789
75790   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75791   {
75792     try {
75793       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75794     } catch (std::out_of_range& e) {
75795       {
75796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75797       };
75798     } catch (std::exception& e) {
75799       {
75800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75801       };
75802     } catch (Dali::DaliException e) {
75803       {
75804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75805       };
75806     } catch (...) {
75807       {
75808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75809       };
75810     }
75811   }
75812
75813   jresult = result;
75814   return jresult;
75815 }
75816
75817
75818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75819   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75820   Dali::Actor *arg2 = 0 ;
75821   int arg3 ;
75822   Dali::Vector3 *arg4 = 0 ;
75823   Dali::Actor *arg5 = 0 ;
75824
75825   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75826   arg2 = (Dali::Actor *)jarg2;
75827   if (!arg2) {
75828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75829     return ;
75830   }
75831   arg3 = (int)jarg3;
75832   arg4 = (Dali::Vector3 *)jarg4;
75833   if (!arg4) {
75834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75835     return ;
75836   }
75837   arg5 = (Dali::Actor *)jarg5;
75838   if (!arg5) {
75839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75840     return ;
75841   }
75842   {
75843     try {
75844       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75845     } catch (std::out_of_range& e) {
75846       {
75847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75848       };
75849     } catch (std::exception& e) {
75850       {
75851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75852       };
75853     } catch (Dali::DaliException e) {
75854       {
75855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75856       };
75857     } catch (...) {
75858       {
75859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75860       };
75861     }
75862   }
75863
75864 }
75865
75866
75867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75868   void * jresult ;
75869   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75870   int arg2 ;
75871   float arg3 ;
75872   Dali::Vector3 *arg4 = 0 ;
75873   Dali::Vector3 result;
75874
75875   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75876   arg2 = (int)jarg2;
75877   arg3 = (float)jarg3;
75878   arg4 = (Dali::Vector3 *)jarg4;
75879   if (!arg4) {
75880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75881     return 0;
75882   }
75883   {
75884     try {
75885       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75886     } catch (std::out_of_range& e) {
75887       {
75888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75889       };
75890     } catch (std::exception& e) {
75891       {
75892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75893       };
75894     } catch (Dali::DaliException e) {
75895       {
75896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75897       };
75898     } catch (...) {
75899       {
75900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75901       };
75902     }
75903   }
75904
75905   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75906   return jresult;
75907 }
75908
75909
75910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75911   void * jresult ;
75912   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75913   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75914
75915   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75916   {
75917     try {
75918       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75919     } catch (std::out_of_range& e) {
75920       {
75921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75922       };
75923     } catch (std::exception& e) {
75924       {
75925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75926       };
75927     } catch (Dali::DaliException e) {
75928       {
75929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75930       };
75931     } catch (...) {
75932       {
75933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75934       };
75935     }
75936   }
75937
75938   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75939   return jresult;
75940 }
75941
75942
75943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75944   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75945
75946   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75947   {
75948     try {
75949       delete arg1;
75950     } catch (std::out_of_range& e) {
75951       {
75952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75953       };
75954     } catch (std::exception& e) {
75955       {
75956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75957       };
75958     } catch (Dali::DaliException e) {
75959       {
75960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75961       };
75962     } catch (...) {
75963       {
75964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75965       };
75966     }
75967   }
75968
75969 }
75970
75971
75972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75973   unsigned int jresult ;
75974   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75975   unsigned int result;
75976
75977   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75978   {
75979     try {
75980       result = (unsigned int)(arg1)->GetNumberOfItems();
75981     } catch (std::out_of_range& e) {
75982       {
75983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75984       };
75985     } catch (std::exception& e) {
75986       {
75987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75988       };
75989     } catch (Dali::DaliException e) {
75990       {
75991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75992       };
75993     } catch (...) {
75994       {
75995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75996       };
75997     }
75998   }
75999
76000   jresult = result;
76001   return jresult;
76002 }
76003
76004
76005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76006   void * jresult ;
76007   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76008   unsigned int arg2 ;
76009   Dali::Actor result;
76010
76011   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76012   arg2 = (unsigned int)jarg2;
76013   {
76014     try {
76015       result = (arg1)->NewItem(arg2);
76016     } catch (std::out_of_range& e) {
76017       {
76018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76019       };
76020     } catch (std::exception& e) {
76021       {
76022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76023       };
76024     } catch (Dali::DaliException e) {
76025       {
76026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76027       };
76028     } catch (...) {
76029       {
76030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76031       };
76032     }
76033   }
76034
76035   jresult = new Dali::Actor((const Dali::Actor &)result);
76036   return jresult;
76037 }
76038
76039
76040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76041   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76042   unsigned int arg2 ;
76043   Dali::Actor arg3 ;
76044   Dali::Actor *argp3 ;
76045
76046   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76047   arg2 = (unsigned int)jarg2;
76048   argp3 = (Dali::Actor *)jarg3;
76049   if (!argp3) {
76050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76051     return ;
76052   }
76053   arg3 = *argp3;
76054   {
76055     try {
76056       (arg1)->ItemReleased(arg2,arg3);
76057     } catch (std::out_of_range& e) {
76058       {
76059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76060       };
76061     } catch (std::exception& e) {
76062       {
76063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76064       };
76065     } catch (Dali::DaliException e) {
76066       {
76067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76068       };
76069     } catch (...) {
76070       {
76071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76072       };
76073     }
76074   }
76075
76076 }
76077
76078
76079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76080   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76081   unsigned int arg2 ;
76082   Dali::Actor arg3 ;
76083   Dali::Actor *argp3 ;
76084
76085   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76086   arg2 = (unsigned int)jarg2;
76087   argp3 = (Dali::Actor *)jarg3;
76088   if (!argp3) {
76089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76090     return ;
76091   }
76092   arg3 = *argp3;
76093   {
76094     try {
76095       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76096     } catch (std::out_of_range& e) {
76097       {
76098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76099       };
76100     } catch (std::exception& e) {
76101       {
76102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76103       };
76104     } catch (Dali::DaliException e) {
76105       {
76106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76107       };
76108     } catch (...) {
76109       {
76110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76111       };
76112     }
76113   }
76114
76115 }
76116
76117
76118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76119   void * jresult ;
76120   Dali::Toolkit::ItemFactory *result = 0 ;
76121
76122   {
76123     try {
76124       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76125     } catch (std::out_of_range& e) {
76126       {
76127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76128       };
76129     } catch (std::exception& e) {
76130       {
76131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76132       };
76133     } catch (Dali::DaliException e) {
76134       {
76135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76136       };
76137     } catch (...) {
76138       {
76139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76140       };
76141     }
76142   }
76143
76144   jresult = (void *)result;
76145   return jresult;
76146 }
76147
76148
76149 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) {
76150   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76151   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76152   if (director) {
76153     director->swig_connect_director(callback0, callback1, callback2);
76154   }
76155 }
76156
76157
76158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76159   int jresult ;
76160   int result;
76161
76162   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76163   jresult = (int)result;
76164   return jresult;
76165 }
76166
76167
76168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76169   int jresult ;
76170   int result;
76171
76172   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76173   jresult = (int)result;
76174   return jresult;
76175 }
76176
76177
76178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76179   int jresult ;
76180   int result;
76181
76182   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76183   jresult = (int)result;
76184   return jresult;
76185 }
76186
76187
76188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76189   int jresult ;
76190   int result;
76191
76192   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76193   jresult = (int)result;
76194   return jresult;
76195 }
76196
76197
76198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76199   int jresult ;
76200   int result;
76201
76202   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76203   jresult = (int)result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76209   int jresult ;
76210   int result;
76211
76212   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76213   jresult = (int)result;
76214   return jresult;
76215 }
76216
76217
76218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76219   int jresult ;
76220   int result;
76221
76222   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76223   jresult = (int)result;
76224   return jresult;
76225 }
76226
76227
76228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76229   int jresult ;
76230   int result;
76231
76232   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76233   jresult = (int)result;
76234   return jresult;
76235 }
76236
76237
76238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76239   int jresult ;
76240   int result;
76241
76242   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76243   jresult = (int)result;
76244   return jresult;
76245 }
76246
76247
76248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76249   int jresult ;
76250   int result;
76251
76252   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76253   jresult = (int)result;
76254   return jresult;
76255 }
76256
76257
76258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76259   int jresult ;
76260   int result;
76261
76262   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76263   jresult = (int)result;
76264   return jresult;
76265 }
76266
76267
76268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76269   void * jresult ;
76270   Dali::Toolkit::ItemView::Property *result = 0 ;
76271
76272   {
76273     try {
76274       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76275     } catch (std::out_of_range& e) {
76276       {
76277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76278       };
76279     } catch (std::exception& e) {
76280       {
76281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76282       };
76283     } catch (Dali::DaliException e) {
76284       {
76285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76286       };
76287     } catch (...) {
76288       {
76289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76290       };
76291     }
76292   }
76293
76294   jresult = (void *)result;
76295   return jresult;
76296 }
76297
76298
76299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76300   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76301
76302   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76303   {
76304     try {
76305       delete arg1;
76306     } catch (std::out_of_range& e) {
76307       {
76308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76309       };
76310     } catch (std::exception& e) {
76311       {
76312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76313       };
76314     } catch (Dali::DaliException e) {
76315       {
76316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76317       };
76318     } catch (...) {
76319       {
76320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76321       };
76322     }
76323   }
76324
76325 }
76326
76327
76328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76329   void * jresult ;
76330   Dali::Toolkit::ItemView *result = 0 ;
76331
76332   {
76333     try {
76334       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76335     } catch (std::out_of_range& e) {
76336       {
76337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76338       };
76339     } catch (std::exception& e) {
76340       {
76341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76342       };
76343     } catch (Dali::DaliException e) {
76344       {
76345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76346       };
76347     } catch (...) {
76348       {
76349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76350       };
76351     }
76352   }
76353
76354   jresult = (void *)result;
76355   return jresult;
76356 }
76357
76358
76359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76360   void * jresult ;
76361   Dali::Toolkit::ItemView *arg1 = 0 ;
76362   Dali::Toolkit::ItemView *result = 0 ;
76363
76364   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76365   if (!arg1) {
76366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76367     return 0;
76368   }
76369   {
76370     try {
76371       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76372     } catch (std::out_of_range& e) {
76373       {
76374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76375       };
76376     } catch (std::exception& e) {
76377       {
76378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76379       };
76380     } catch (Dali::DaliException e) {
76381       {
76382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76383       };
76384     } catch (...) {
76385       {
76386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76387       };
76388     }
76389   }
76390
76391   jresult = (void *)result;
76392   return jresult;
76393 }
76394
76395
76396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76397   void * jresult ;
76398   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76399   Dali::Toolkit::ItemView *arg2 = 0 ;
76400   Dali::Toolkit::ItemView *result = 0 ;
76401
76402   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76403   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76404   if (!arg2) {
76405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76406     return 0;
76407   }
76408   {
76409     try {
76410       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76411     } catch (std::out_of_range& e) {
76412       {
76413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76414       };
76415     } catch (std::exception& e) {
76416       {
76417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76418       };
76419     } catch (Dali::DaliException e) {
76420       {
76421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76422       };
76423     } catch (...) {
76424       {
76425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76426       };
76427     }
76428   }
76429
76430   jresult = (void *)result;
76431   return jresult;
76432 }
76433
76434
76435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76436   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76437
76438   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76439   {
76440     try {
76441       delete arg1;
76442     } catch (std::out_of_range& e) {
76443       {
76444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76445       };
76446     } catch (std::exception& e) {
76447       {
76448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76449       };
76450     } catch (Dali::DaliException e) {
76451       {
76452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76453       };
76454     } catch (...) {
76455       {
76456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76457       };
76458     }
76459   }
76460
76461 }
76462
76463
76464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76465   void * jresult ;
76466   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76467   Dali::Toolkit::ItemView result;
76468
76469   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76470   if (!arg1) {
76471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76472     return 0;
76473   }
76474   {
76475     try {
76476       result = Dali::Toolkit::ItemView::New(*arg1);
76477     } catch (std::out_of_range& e) {
76478       {
76479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76480       };
76481     } catch (std::exception& e) {
76482       {
76483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76484       };
76485     } catch (Dali::DaliException e) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76488       };
76489     } catch (...) {
76490       {
76491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76492       };
76493     }
76494   }
76495
76496   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76497   return jresult;
76498 }
76499
76500
76501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76502   void * jresult ;
76503   Dali::BaseHandle arg1 ;
76504   Dali::BaseHandle *argp1 ;
76505   Dali::Toolkit::ItemView result;
76506
76507   argp1 = (Dali::BaseHandle *)jarg1;
76508   if (!argp1) {
76509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76510     return 0;
76511   }
76512   arg1 = *argp1;
76513   {
76514     try {
76515       result = Dali::Toolkit::ItemView::DownCast(arg1);
76516     } catch (std::out_of_range& e) {
76517       {
76518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76519       };
76520     } catch (std::exception& e) {
76521       {
76522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76523       };
76524     } catch (Dali::DaliException e) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76527       };
76528     } catch (...) {
76529       {
76530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76531       };
76532     }
76533   }
76534
76535   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76536   return jresult;
76537 }
76538
76539
76540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76541   unsigned int jresult ;
76542   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76543   unsigned int result;
76544
76545   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76546   {
76547     try {
76548       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76549     } catch (std::out_of_range& e) {
76550       {
76551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76552       };
76553     } catch (std::exception& e) {
76554       {
76555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76556       };
76557     } catch (Dali::DaliException e) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76560       };
76561     } catch (...) {
76562       {
76563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76564       };
76565     }
76566   }
76567
76568   jresult = result;
76569   return jresult;
76570 }
76571
76572
76573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76574   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76575   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76576
76577   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76578   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76579   if (!arg2) {
76580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76581     return ;
76582   }
76583   {
76584     try {
76585       (arg1)->AddLayout(*arg2);
76586     } catch (std::out_of_range& e) {
76587       {
76588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76589       };
76590     } catch (std::exception& e) {
76591       {
76592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76593       };
76594     } catch (Dali::DaliException e) {
76595       {
76596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76597       };
76598     } catch (...) {
76599       {
76600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76601       };
76602     }
76603   }
76604
76605 }
76606
76607
76608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76609   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76610   unsigned int arg2 ;
76611
76612   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76613   arg2 = (unsigned int)jarg2;
76614   {
76615     try {
76616       (arg1)->RemoveLayout(arg2);
76617     } catch (std::out_of_range& e) {
76618       {
76619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76620       };
76621     } catch (std::exception& e) {
76622       {
76623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76624       };
76625     } catch (Dali::DaliException e) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76628       };
76629     } catch (...) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76632       };
76633     }
76634   }
76635
76636 }
76637
76638
76639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76640   void * jresult ;
76641   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76642   unsigned int arg2 ;
76643   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76644
76645   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76646   arg2 = (unsigned int)jarg2;
76647   {
76648     try {
76649       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76650     } catch (std::out_of_range& e) {
76651       {
76652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76653       };
76654     } catch (std::exception& e) {
76655       {
76656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76657       };
76658     } catch (Dali::DaliException e) {
76659       {
76660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76661       };
76662     } catch (...) {
76663       {
76664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76665       };
76666     }
76667   }
76668
76669   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76670   return jresult;
76671 }
76672
76673
76674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76675   void * jresult ;
76676   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76677   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76678
76679   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76680   {
76681     try {
76682       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76683     } catch (std::out_of_range& e) {
76684       {
76685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76686       };
76687     } catch (std::exception& e) {
76688       {
76689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76690       };
76691     } catch (Dali::DaliException e) {
76692       {
76693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76694       };
76695     } catch (...) {
76696       {
76697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76698       };
76699     }
76700   }
76701
76702   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76703   return jresult;
76704 }
76705
76706
76707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76708   float jresult ;
76709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76710   Dali::Toolkit::ItemId arg2 ;
76711   float result;
76712
76713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76714   arg2 = (Dali::Toolkit::ItemId)jarg2;
76715   {
76716     try {
76717       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76718     } catch (std::out_of_range& e) {
76719       {
76720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76721       };
76722     } catch (std::exception& e) {
76723       {
76724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76725       };
76726     } catch (Dali::DaliException e) {
76727       {
76728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76729       };
76730     } catch (...) {
76731       {
76732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76733       };
76734     }
76735   }
76736
76737   jresult = result;
76738   return jresult;
76739 }
76740
76741
76742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76743   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76744   unsigned int arg2 ;
76745   Dali::Vector3 arg3 ;
76746   float arg4 ;
76747   Dali::Vector3 *argp3 ;
76748
76749   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76750   arg2 = (unsigned int)jarg2;
76751   argp3 = (Dali::Vector3 *)jarg3;
76752   if (!argp3) {
76753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76754     return ;
76755   }
76756   arg3 = *argp3;
76757   arg4 = (float)jarg4;
76758   {
76759     try {
76760       (arg1)->ActivateLayout(arg2,arg3,arg4);
76761     } catch (std::out_of_range& e) {
76762       {
76763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76764       };
76765     } catch (std::exception& e) {
76766       {
76767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76768       };
76769     } catch (Dali::DaliException e) {
76770       {
76771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76772       };
76773     } catch (...) {
76774       {
76775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76776       };
76777     }
76778   }
76779
76780 }
76781
76782
76783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76784   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76785
76786   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76787   {
76788     try {
76789       (arg1)->DeactivateCurrentLayout();
76790     } catch (std::out_of_range& e) {
76791       {
76792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76793       };
76794     } catch (std::exception& e) {
76795       {
76796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76797       };
76798     } catch (Dali::DaliException e) {
76799       {
76800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76801       };
76802     } catch (...) {
76803       {
76804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76805       };
76806     }
76807   }
76808
76809 }
76810
76811
76812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76813   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76814   float arg2 ;
76815
76816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76817   arg2 = (float)jarg2;
76818   {
76819     try {
76820       (arg1)->SetMinimumSwipeSpeed(arg2);
76821     } catch (std::out_of_range& e) {
76822       {
76823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76824       };
76825     } catch (std::exception& e) {
76826       {
76827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76828       };
76829     } catch (Dali::DaliException e) {
76830       {
76831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76832       };
76833     } catch (...) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76836       };
76837     }
76838   }
76839
76840 }
76841
76842
76843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76844   float jresult ;
76845   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76846   float result;
76847
76848   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76849   {
76850     try {
76851       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76852     } catch (std::out_of_range& e) {
76853       {
76854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76855       };
76856     } catch (std::exception& e) {
76857       {
76858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76859       };
76860     } catch (Dali::DaliException e) {
76861       {
76862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76863       };
76864     } catch (...) {
76865       {
76866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76867       };
76868     }
76869   }
76870
76871   jresult = result;
76872   return jresult;
76873 }
76874
76875
76876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76877   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76878   float arg2 ;
76879
76880   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76881   arg2 = (float)jarg2;
76882   {
76883     try {
76884       (arg1)->SetMinimumSwipeDistance(arg2);
76885     } catch (std::out_of_range& e) {
76886       {
76887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76888       };
76889     } catch (std::exception& e) {
76890       {
76891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76892       };
76893     } catch (Dali::DaliException e) {
76894       {
76895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76896       };
76897     } catch (...) {
76898       {
76899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76900       };
76901     }
76902   }
76903
76904 }
76905
76906
76907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76908   float jresult ;
76909   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76910   float result;
76911
76912   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76913   {
76914     try {
76915       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76916     } catch (std::out_of_range& e) {
76917       {
76918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76919       };
76920     } catch (std::exception& e) {
76921       {
76922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76923       };
76924     } catch (Dali::DaliException e) {
76925       {
76926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76927       };
76928     } catch (...) {
76929       {
76930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76931       };
76932     }
76933   }
76934
76935   jresult = result;
76936   return jresult;
76937 }
76938
76939
76940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76941   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76942   float arg2 ;
76943
76944   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76945   arg2 = (float)jarg2;
76946   {
76947     try {
76948       (arg1)->SetWheelScrollDistanceStep(arg2);
76949     } catch (std::out_of_range& e) {
76950       {
76951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76952       };
76953     } catch (std::exception& e) {
76954       {
76955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76956       };
76957     } catch (Dali::DaliException e) {
76958       {
76959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76960       };
76961     } catch (...) {
76962       {
76963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76964       };
76965     }
76966   }
76967
76968 }
76969
76970
76971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76972   float jresult ;
76973   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76974   float result;
76975
76976   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76977   {
76978     try {
76979       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76980     } catch (std::out_of_range& e) {
76981       {
76982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76983       };
76984     } catch (std::exception& e) {
76985       {
76986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76987       };
76988     } catch (Dali::DaliException e) {
76989       {
76990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76991       };
76992     } catch (...) {
76993       {
76994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76995       };
76996     }
76997   }
76998
76999   jresult = result;
77000   return jresult;
77001 }
77002
77003
77004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77005   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77006   bool arg2 ;
77007
77008   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77009   arg2 = jarg2 ? true : false;
77010   {
77011     try {
77012       (arg1)->SetAnchoring(arg2);
77013     } catch (std::out_of_range& e) {
77014       {
77015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77016       };
77017     } catch (std::exception& e) {
77018       {
77019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77020       };
77021     } catch (Dali::DaliException e) {
77022       {
77023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77024       };
77025     } catch (...) {
77026       {
77027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77028       };
77029     }
77030   }
77031
77032 }
77033
77034 //// ========================= end of part 3 =============================
77035
77036 //// ========================== start part 4 ===============================
77037
77038
77039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77040   unsigned int jresult ;
77041   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77042   bool result;
77043
77044   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77045   {
77046     try {
77047       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77048     } catch (std::out_of_range& e) {
77049       {
77050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77051       };
77052     } catch (std::exception& e) {
77053       {
77054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77055       };
77056     } catch (Dali::DaliException e) {
77057       {
77058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77059       };
77060     } catch (...) {
77061       {
77062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77063       };
77064     }
77065   }
77066
77067   jresult = result;
77068   return jresult;
77069 }
77070
77071
77072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77073   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77074   float arg2 ;
77075
77076   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77077   arg2 = (float)jarg2;
77078   {
77079     try {
77080       (arg1)->SetAnchoringDuration(arg2);
77081     } catch (std::out_of_range& e) {
77082       {
77083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77084       };
77085     } catch (std::exception& e) {
77086       {
77087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77088       };
77089     } catch (Dali::DaliException e) {
77090       {
77091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77092       };
77093     } catch (...) {
77094       {
77095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77096       };
77097     }
77098   }
77099
77100 }
77101
77102
77103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77104   float jresult ;
77105   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77106   float result;
77107
77108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77109   {
77110     try {
77111       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77112     } catch (std::out_of_range& e) {
77113       {
77114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77115       };
77116     } catch (std::exception& e) {
77117       {
77118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77119       };
77120     } catch (Dali::DaliException e) {
77121       {
77122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77123       };
77124     } catch (...) {
77125       {
77126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77127       };
77128     }
77129   }
77130
77131   jresult = result;
77132   return jresult;
77133 }
77134
77135
77136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77137   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77138   Dali::Toolkit::ItemId arg2 ;
77139   float arg3 ;
77140
77141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77142   arg2 = (Dali::Toolkit::ItemId)jarg2;
77143   arg3 = (float)jarg3;
77144   {
77145     try {
77146       (arg1)->ScrollToItem(arg2,arg3);
77147     } catch (std::out_of_range& e) {
77148       {
77149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77150       };
77151     } catch (std::exception& e) {
77152       {
77153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77154       };
77155     } catch (Dali::DaliException e) {
77156       {
77157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77158       };
77159     } catch (...) {
77160       {
77161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77162       };
77163     }
77164   }
77165
77166 }
77167
77168
77169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77170   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77171   float arg2 ;
77172
77173   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77174   arg2 = (float)jarg2;
77175   {
77176     try {
77177       (arg1)->SetRefreshInterval(arg2);
77178     } catch (std::out_of_range& e) {
77179       {
77180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77181       };
77182     } catch (std::exception& e) {
77183       {
77184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77185       };
77186     } catch (Dali::DaliException e) {
77187       {
77188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77189       };
77190     } catch (...) {
77191       {
77192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77193       };
77194     }
77195   }
77196
77197 }
77198
77199
77200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77201   float jresult ;
77202   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77203   float result;
77204
77205   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77206   {
77207     try {
77208       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77209     } catch (std::out_of_range& e) {
77210       {
77211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77212       };
77213     } catch (std::exception& e) {
77214       {
77215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77216       };
77217     } catch (Dali::DaliException e) {
77218       {
77219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77220       };
77221     } catch (...) {
77222       {
77223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77224       };
77225     }
77226   }
77227
77228   jresult = result;
77229   return jresult;
77230 }
77231
77232
77233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77234   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77235
77236   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77237   {
77238     try {
77239       (arg1)->Refresh();
77240     } catch (std::out_of_range& e) {
77241       {
77242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77243       };
77244     } catch (std::exception& e) {
77245       {
77246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77247       };
77248     } catch (Dali::DaliException e) {
77249       {
77250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77251       };
77252     } catch (...) {
77253       {
77254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77255       };
77256     }
77257   }
77258
77259 }
77260
77261
77262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77263   void * jresult ;
77264   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77265   Dali::Toolkit::ItemId arg2 ;
77266   Dali::Actor result;
77267
77268   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77269   arg2 = (Dali::Toolkit::ItemId)jarg2;
77270   {
77271     try {
77272       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77273     } catch (std::out_of_range& e) {
77274       {
77275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77276       };
77277     } catch (std::exception& e) {
77278       {
77279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77280       };
77281     } catch (Dali::DaliException e) {
77282       {
77283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77284       };
77285     } catch (...) {
77286       {
77287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77288       };
77289     }
77290   }
77291
77292   jresult = new Dali::Actor((const Dali::Actor &)result);
77293   return jresult;
77294 }
77295
77296
77297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77298   unsigned int jresult ;
77299   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77300   Dali::Actor arg2 ;
77301   Dali::Actor *argp2 ;
77302   Dali::Toolkit::ItemId result;
77303
77304   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77305   argp2 = (Dali::Actor *)jarg2;
77306   if (!argp2) {
77307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77308     return 0;
77309   }
77310   arg2 = *argp2;
77311   {
77312     try {
77313       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77314     } catch (std::out_of_range& e) {
77315       {
77316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77317       };
77318     } catch (std::exception& e) {
77319       {
77320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77321       };
77322     } catch (Dali::DaliException e) {
77323       {
77324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77325       };
77326     } catch (...) {
77327       {
77328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77329       };
77330     }
77331   }
77332
77333   jresult = result;
77334   return jresult;
77335 }
77336
77337
77338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77339   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77340   Dali::Toolkit::Item arg2 ;
77341   float arg3 ;
77342   Dali::Toolkit::Item *argp2 ;
77343
77344   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77345   argp2 = (Dali::Toolkit::Item *)jarg2;
77346   if (!argp2) {
77347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77348     return ;
77349   }
77350   arg2 = *argp2;
77351   arg3 = (float)jarg3;
77352   {
77353     try {
77354       (arg1)->InsertItem(arg2,arg3);
77355     } catch (std::out_of_range& e) {
77356       {
77357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77358       };
77359     } catch (std::exception& e) {
77360       {
77361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77362       };
77363     } catch (Dali::DaliException e) {
77364       {
77365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77366       };
77367     } catch (...) {
77368       {
77369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77370       };
77371     }
77372   }
77373
77374 }
77375
77376
77377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77378   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77379   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77380   float arg3 ;
77381
77382   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77383   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77384   if (!arg2) {
77385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77386     return ;
77387   }
77388   arg3 = (float)jarg3;
77389   {
77390     try {
77391       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77392     } catch (std::out_of_range& e) {
77393       {
77394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77395       };
77396     } catch (std::exception& e) {
77397       {
77398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77399       };
77400     } catch (Dali::DaliException e) {
77401       {
77402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77403       };
77404     } catch (...) {
77405       {
77406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77407       };
77408     }
77409   }
77410
77411 }
77412
77413
77414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77415   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77416   Dali::Toolkit::ItemId arg2 ;
77417   float arg3 ;
77418
77419   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77420   arg2 = (Dali::Toolkit::ItemId)jarg2;
77421   arg3 = (float)jarg3;
77422   {
77423     try {
77424       (arg1)->RemoveItem(arg2,arg3);
77425     } catch (std::out_of_range& e) {
77426       {
77427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77428       };
77429     } catch (std::exception& e) {
77430       {
77431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77432       };
77433     } catch (Dali::DaliException e) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77436       };
77437     } catch (...) {
77438       {
77439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77440       };
77441     }
77442   }
77443
77444 }
77445
77446
77447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77448   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77449   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77450   float arg3 ;
77451
77452   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77453   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77454   if (!arg2) {
77455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77456     return ;
77457   }
77458   arg3 = (float)jarg3;
77459   {
77460     try {
77461       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77462     } catch (std::out_of_range& e) {
77463       {
77464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77465       };
77466     } catch (std::exception& e) {
77467       {
77468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77469       };
77470     } catch (Dali::DaliException e) {
77471       {
77472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77473       };
77474     } catch (...) {
77475       {
77476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77477       };
77478     }
77479   }
77480
77481 }
77482
77483
77484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77485   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77486   Dali::Toolkit::Item arg2 ;
77487   float arg3 ;
77488   Dali::Toolkit::Item *argp2 ;
77489
77490   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77491   argp2 = (Dali::Toolkit::Item *)jarg2;
77492   if (!argp2) {
77493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77494     return ;
77495   }
77496   arg2 = *argp2;
77497   arg3 = (float)jarg3;
77498   {
77499     try {
77500       (arg1)->ReplaceItem(arg2,arg3);
77501     } catch (std::out_of_range& e) {
77502       {
77503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77504       };
77505     } catch (std::exception& e) {
77506       {
77507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77508       };
77509     } catch (Dali::DaliException e) {
77510       {
77511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77512       };
77513     } catch (...) {
77514       {
77515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77516       };
77517     }
77518   }
77519
77520 }
77521
77522
77523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77524   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77525   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77526   float arg3 ;
77527
77528   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77529   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77530   if (!arg2) {
77531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77532     return ;
77533   }
77534   arg3 = (float)jarg3;
77535   {
77536     try {
77537       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77538     } catch (std::out_of_range& e) {
77539       {
77540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77541       };
77542     } catch (std::exception& e) {
77543       {
77544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77545       };
77546     } catch (Dali::DaliException e) {
77547       {
77548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77549       };
77550     } catch (...) {
77551       {
77552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77553       };
77554     }
77555   }
77556
77557 }
77558
77559
77560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77562   Dali::Vector3 *arg2 = 0 ;
77563
77564   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77565   arg2 = (Dali::Vector3 *)jarg2;
77566   if (!arg2) {
77567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77568     return ;
77569   }
77570   {
77571     try {
77572       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77573     } catch (std::out_of_range& e) {
77574       {
77575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77576       };
77577     } catch (std::exception& e) {
77578       {
77579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77580       };
77581     } catch (Dali::DaliException e) {
77582       {
77583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77584       };
77585     } catch (...) {
77586       {
77587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77588       };
77589     }
77590   }
77591
77592 }
77593
77594
77595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77596   void * jresult ;
77597   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77598   Dali::Vector3 result;
77599
77600   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77601   {
77602     try {
77603       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77604     } catch (std::out_of_range& e) {
77605       {
77606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77607       };
77608     } catch (std::exception& e) {
77609       {
77610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77611       };
77612     } catch (Dali::DaliException e) {
77613       {
77614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77615       };
77616     } catch (...) {
77617       {
77618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77619       };
77620     }
77621   }
77622
77623   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77624   return jresult;
77625 }
77626
77627
77628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77630   Dali::Vector3 *arg2 = 0 ;
77631
77632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77633   arg2 = (Dali::Vector3 *)jarg2;
77634   if (!arg2) {
77635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77636     return ;
77637   }
77638   {
77639     try {
77640       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77641     } catch (std::out_of_range& e) {
77642       {
77643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77644       };
77645     } catch (std::exception& e) {
77646       {
77647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77648       };
77649     } catch (Dali::DaliException e) {
77650       {
77651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77652       };
77653     } catch (...) {
77654       {
77655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77656       };
77657     }
77658   }
77659
77660 }
77661
77662
77663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77664   void * jresult ;
77665   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77666   Dali::Vector3 result;
77667
77668   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77669   {
77670     try {
77671       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77672     } catch (std::out_of_range& e) {
77673       {
77674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77675       };
77676     } catch (std::exception& e) {
77677       {
77678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77679       };
77680     } catch (Dali::DaliException e) {
77681       {
77682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77683       };
77684     } catch (...) {
77685       {
77686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77687       };
77688     }
77689   }
77690
77691   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77692   return jresult;
77693 }
77694
77695
77696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77697   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77698   Dali::Toolkit::ItemRange *arg2 = 0 ;
77699
77700   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77701   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77702   if (!arg2) {
77703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77704     return ;
77705   }
77706   {
77707     try {
77708       (arg1)->GetItemsRange(*arg2);
77709     } catch (std::out_of_range& e) {
77710       {
77711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77712       };
77713     } catch (std::exception& e) {
77714       {
77715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77716       };
77717     } catch (Dali::DaliException e) {
77718       {
77719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77720       };
77721     } catch (...) {
77722       {
77723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77724       };
77725     }
77726   }
77727
77728 }
77729
77730
77731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77732   void * jresult ;
77733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77734   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77735
77736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77737   {
77738     try {
77739       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77740     } catch (std::out_of_range& e) {
77741       {
77742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77743       };
77744     } catch (std::exception& e) {
77745       {
77746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (Dali::DaliException e) {
77749       {
77750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77751       };
77752     } catch (...) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77755       };
77756     }
77757   }
77758
77759   jresult = (void *)result;
77760   return jresult;
77761 }
77762
77763
77764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77765   Dali::Vector3 *arg1 = 0 ;
77766   PropertyInputContainer *arg2 = 0 ;
77767
77768   arg1 = (Dali::Vector3 *)jarg1;
77769   if (!arg1) {
77770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77771     return ;
77772   }
77773   arg2 = (PropertyInputContainer *)jarg2;
77774   if (!arg2) {
77775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77776     return ;
77777   }
77778   {
77779     try {
77780       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77781     } catch (std::out_of_range& e) {
77782       {
77783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77784       };
77785     } catch (std::exception& e) {
77786       {
77787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77788       };
77789     } catch (Dali::DaliException e) {
77790       {
77791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77792       };
77793     } catch (...) {
77794       {
77795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77796       };
77797     }
77798   }
77799
77800 }
77801
77802
77803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77804   Dali::Vector3 *arg1 = 0 ;
77805   PropertyInputContainer *arg2 = 0 ;
77806
77807   arg1 = (Dali::Vector3 *)jarg1;
77808   if (!arg1) {
77809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77810     return ;
77811   }
77812   arg2 = (PropertyInputContainer *)jarg2;
77813   if (!arg2) {
77814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77815     return ;
77816   }
77817   {
77818     try {
77819       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77820     } catch (std::out_of_range& e) {
77821       {
77822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77823       };
77824     } catch (std::exception& e) {
77825       {
77826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77827       };
77828     } catch (Dali::DaliException e) {
77829       {
77830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77831       };
77832     } catch (...) {
77833       {
77834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77835       };
77836     }
77837   }
77838
77839 }
77840
77841
77842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77843   void * jresult ;
77844   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77845
77846   {
77847     try {
77848       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77849     } catch (std::out_of_range& e) {
77850       {
77851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77852       };
77853     } catch (std::exception& e) {
77854       {
77855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77856       };
77857     } catch (Dali::DaliException e) {
77858       {
77859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77860       };
77861     } catch (...) {
77862       {
77863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77864       };
77865     }
77866   }
77867
77868   jresult = (void *)result;
77869   return jresult;
77870 }
77871
77872
77873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77874   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77875
77876   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77877   {
77878     try {
77879       delete arg1;
77880     } catch (std::out_of_range& e) {
77881       {
77882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77883       };
77884     } catch (std::exception& e) {
77885       {
77886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77887       };
77888     } catch (Dali::DaliException e) {
77889       {
77890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77891       };
77892     } catch (...) {
77893       {
77894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77895       };
77896     }
77897   }
77898
77899 }
77900
77901
77902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77903   void * jresult ;
77904   Dali::Path arg1 ;
77905   Dali::Vector3 *arg2 = 0 ;
77906   Dali::Property::Index arg3 ;
77907   Dali::Vector3 *arg4 = 0 ;
77908   unsigned int arg5 ;
77909   Dali::Path *argp1 ;
77910   Dali::Toolkit::ScrollViewPagePathEffect result;
77911
77912   argp1 = (Dali::Path *)jarg1;
77913   if (!argp1) {
77914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77915     return 0;
77916   }
77917   arg1 = *argp1;
77918   arg2 = (Dali::Vector3 *)jarg2;
77919   if (!arg2) {
77920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77921     return 0;
77922   }
77923   arg3 = (Dali::Property::Index)jarg3;
77924   arg4 = (Dali::Vector3 *)jarg4;
77925   if (!arg4) {
77926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77927     return 0;
77928   }
77929   arg5 = (unsigned int)jarg5;
77930   {
77931     try {
77932       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77933     } catch (std::out_of_range& e) {
77934       {
77935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77936       };
77937     } catch (std::exception& e) {
77938       {
77939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77940       };
77941     } catch (Dali::DaliException e) {
77942       {
77943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77944       };
77945     } catch (...) {
77946       {
77947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77948       };
77949     }
77950   }
77951
77952   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77953   return jresult;
77954 }
77955
77956
77957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77958   void * jresult ;
77959   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77960
77961   {
77962     try {
77963       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77964     } catch (std::out_of_range& e) {
77965       {
77966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77967       };
77968     } catch (std::exception& e) {
77969       {
77970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77971       };
77972     } catch (Dali::DaliException e) {
77973       {
77974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77975       };
77976     } catch (...) {
77977       {
77978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77979       };
77980     }
77981   }
77982
77983   jresult = (void *)result;
77984   return jresult;
77985 }
77986
77987
77988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77989   void * jresult ;
77990   Dali::BaseHandle arg1 ;
77991   Dali::BaseHandle *argp1 ;
77992   Dali::Toolkit::ScrollViewPagePathEffect result;
77993
77994   argp1 = (Dali::BaseHandle *)jarg1;
77995   if (!argp1) {
77996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77997     return 0;
77998   }
77999   arg1 = *argp1;
78000   {
78001     try {
78002       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78003     } catch (std::out_of_range& e) {
78004       {
78005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78006       };
78007     } catch (std::exception& e) {
78008       {
78009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78010       };
78011     } catch (Dali::DaliException e) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78014       };
78015     } catch (...) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78018       };
78019     }
78020   }
78021
78022   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78023   return jresult;
78024 }
78025
78026
78027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78028   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78029   Dali::Actor arg2 ;
78030   unsigned int arg3 ;
78031   Dali::Actor *argp2 ;
78032
78033   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78034   argp2 = (Dali::Actor *)jarg2;
78035   if (!argp2) {
78036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78037     return ;
78038   }
78039   arg2 = *argp2;
78040   arg3 = (unsigned int)jarg3;
78041   {
78042     try {
78043       (arg1)->ApplyToPage(arg2,arg3);
78044     } catch (std::out_of_range& e) {
78045       {
78046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78047       };
78048     } catch (std::exception& e) {
78049       {
78050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78051       };
78052     } catch (Dali::DaliException e) {
78053       {
78054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78055       };
78056     } catch (...) {
78057       {
78058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78059       };
78060     }
78061   }
78062
78063 }
78064
78065
78066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78067   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78068
78069   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78070   {
78071     try {
78072       delete arg1;
78073     } catch (std::out_of_range& e) {
78074       {
78075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78076       };
78077     } catch (std::exception& e) {
78078       {
78079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78080       };
78081     } catch (Dali::DaliException e) {
78082       {
78083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78084       };
78085     } catch (...) {
78086       {
78087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78088       };
78089     }
78090   }
78091
78092 }
78093
78094
78095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78096   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78097   Dali::Toolkit::ClampState arg2 ;
78098
78099   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78100   arg2 = (Dali::Toolkit::ClampState)jarg2;
78101   if (arg1) (arg1)->x = arg2;
78102 }
78103
78104
78105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78106   int jresult ;
78107   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78108   Dali::Toolkit::ClampState result;
78109
78110   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78111   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78112   jresult = (int)result;
78113   return jresult;
78114 }
78115
78116
78117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78118   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78119   Dali::Toolkit::ClampState arg2 ;
78120
78121   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78122   arg2 = (Dali::Toolkit::ClampState)jarg2;
78123   if (arg1) (arg1)->y = arg2;
78124 }
78125
78126
78127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78128   int jresult ;
78129   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78130   Dali::Toolkit::ClampState result;
78131
78132   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78133   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78134   jresult = (int)result;
78135   return jresult;
78136 }
78137
78138
78139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78140   void * jresult ;
78141   Dali::Toolkit::ClampState2D *result = 0 ;
78142
78143   {
78144     try {
78145       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78146     } catch (std::out_of_range& e) {
78147       {
78148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78149       };
78150     } catch (std::exception& e) {
78151       {
78152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78153       };
78154     } catch (Dali::DaliException e) {
78155       {
78156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78157       };
78158     } catch (...) {
78159       {
78160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78161       };
78162     }
78163   }
78164
78165   jresult = (void *)result;
78166   return jresult;
78167 }
78168
78169
78170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78171   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78172
78173   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78174   {
78175     try {
78176       delete arg1;
78177     } catch (std::out_of_range& e) {
78178       {
78179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78180       };
78181     } catch (std::exception& e) {
78182       {
78183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78184       };
78185     } catch (Dali::DaliException e) {
78186       {
78187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78188       };
78189     } catch (...) {
78190       {
78191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78192       };
78193     }
78194   }
78195
78196 }
78197
78198
78199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78200   void * jresult ;
78201   float arg1 ;
78202   float arg2 ;
78203   bool arg3 ;
78204   Dali::Toolkit::RulerDomain *result = 0 ;
78205
78206   arg1 = (float)jarg1;
78207   arg2 = (float)jarg2;
78208   arg3 = jarg3 ? true : false;
78209   {
78210     try {
78211       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
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 = (void *)result;
78232   return jresult;
78233 }
78234
78235
78236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78237   void * jresult ;
78238   float arg1 ;
78239   float arg2 ;
78240   Dali::Toolkit::RulerDomain *result = 0 ;
78241
78242   arg1 = (float)jarg1;
78243   arg2 = (float)jarg2;
78244   {
78245     try {
78246       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78247     } catch (std::out_of_range& e) {
78248       {
78249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78250       };
78251     } catch (std::exception& e) {
78252       {
78253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78254       };
78255     } catch (Dali::DaliException e) {
78256       {
78257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78258       };
78259     } catch (...) {
78260       {
78261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78262       };
78263     }
78264   }
78265
78266   jresult = (void *)result;
78267   return jresult;
78268 }
78269
78270
78271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78272   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78273   float arg2 ;
78274
78275   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78276   arg2 = (float)jarg2;
78277   if (arg1) (arg1)->min = arg2;
78278 }
78279
78280
78281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78282   float jresult ;
78283   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78284   float result;
78285
78286   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78287   result = (float) ((arg1)->min);
78288   jresult = result;
78289   return jresult;
78290 }
78291
78292
78293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78294   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78295   float arg2 ;
78296
78297   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78298   arg2 = (float)jarg2;
78299   if (arg1) (arg1)->max = arg2;
78300 }
78301
78302
78303 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78304   float jresult ;
78305   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78306   float result;
78307
78308   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78309   result = (float) ((arg1)->max);
78310   jresult = result;
78311   return jresult;
78312 }
78313
78314
78315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78316   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78317   bool arg2 ;
78318
78319   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78320   arg2 = jarg2 ? true : false;
78321   if (arg1) (arg1)->enabled = arg2;
78322 }
78323
78324
78325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78326   unsigned int jresult ;
78327   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78328   bool result;
78329
78330   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78331   result = (bool) ((arg1)->enabled);
78332   jresult = result;
78333   return jresult;
78334 }
78335
78336
78337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78338   float jresult ;
78339   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78340   float arg2 ;
78341   float arg3 ;
78342   float arg4 ;
78343   float result;
78344
78345   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78346   arg2 = (float)jarg2;
78347   arg3 = (float)jarg3;
78348   arg4 = (float)jarg4;
78349   {
78350     try {
78351       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78352     } catch (std::out_of_range& e) {
78353       {
78354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78355       };
78356     } catch (std::exception& e) {
78357       {
78358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78359       };
78360     } catch (Dali::DaliException e) {
78361       {
78362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78363       };
78364     } catch (...) {
78365       {
78366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78367       };
78368     }
78369   }
78370
78371   jresult = result;
78372   return jresult;
78373 }
78374
78375
78376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78377   float jresult ;
78378   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78379   float arg2 ;
78380   float arg3 ;
78381   float result;
78382
78383   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78384   arg2 = (float)jarg2;
78385   arg3 = (float)jarg3;
78386   {
78387     try {
78388       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78389     } catch (std::out_of_range& e) {
78390       {
78391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78392       };
78393     } catch (std::exception& e) {
78394       {
78395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78396       };
78397     } catch (Dali::DaliException e) {
78398       {
78399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78400       };
78401     } catch (...) {
78402       {
78403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78404       };
78405     }
78406   }
78407
78408   jresult = result;
78409   return jresult;
78410 }
78411
78412
78413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78414   float jresult ;
78415   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78416   float arg2 ;
78417   float result;
78418
78419   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78420   arg2 = (float)jarg2;
78421   {
78422     try {
78423       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78424     } catch (std::out_of_range& e) {
78425       {
78426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78427       };
78428     } catch (std::exception& e) {
78429       {
78430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78431       };
78432     } catch (Dali::DaliException e) {
78433       {
78434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78435       };
78436     } catch (...) {
78437       {
78438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78439       };
78440     }
78441   }
78442
78443   jresult = result;
78444   return jresult;
78445 }
78446
78447
78448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78449   float jresult ;
78450   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78451   float arg2 ;
78452   float arg3 ;
78453   float arg4 ;
78454   Dali::Toolkit::ClampState *arg5 = 0 ;
78455   float result;
78456
78457   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78458   arg2 = (float)jarg2;
78459   arg3 = (float)jarg3;
78460   arg4 = (float)jarg4;
78461   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78462   if (!arg5) {
78463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78464     return 0;
78465   }
78466   {
78467     try {
78468       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78469     } catch (std::out_of_range& e) {
78470       {
78471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78472       };
78473     } catch (std::exception& e) {
78474       {
78475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78476       };
78477     } catch (Dali::DaliException e) {
78478       {
78479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78480       };
78481     } catch (...) {
78482       {
78483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78484       };
78485     }
78486   }
78487
78488   jresult = result;
78489   return jresult;
78490 }
78491
78492
78493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78494   float jresult ;
78495   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78496   float result;
78497
78498   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78499   {
78500     try {
78501       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78502     } catch (std::out_of_range& e) {
78503       {
78504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78505       };
78506     } catch (std::exception& e) {
78507       {
78508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78509       };
78510     } catch (Dali::DaliException e) {
78511       {
78512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78513       };
78514     } catch (...) {
78515       {
78516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78517       };
78518     }
78519   }
78520
78521   jresult = result;
78522   return jresult;
78523 }
78524
78525
78526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78527   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78528
78529   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78530   {
78531     try {
78532       delete arg1;
78533     } catch (std::out_of_range& e) {
78534       {
78535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78536       };
78537     } catch (std::exception& e) {
78538       {
78539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78540       };
78541     } catch (Dali::DaliException e) {
78542       {
78543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78544       };
78545     } catch (...) {
78546       {
78547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78548       };
78549     }
78550   }
78551
78552 }
78553
78554
78555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78556   float jresult ;
78557   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78558   float arg2 ;
78559   float arg3 ;
78560   float result;
78561
78562   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78563   arg2 = (float)jarg2;
78564   arg3 = (float)jarg3;
78565   {
78566     try {
78567       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78568     } catch (std::out_of_range& e) {
78569       {
78570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78571       };
78572     } catch (std::exception& e) {
78573       {
78574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78575       };
78576     } catch (Dali::DaliException e) {
78577       {
78578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78579       };
78580     } catch (...) {
78581       {
78582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78583       };
78584     }
78585   }
78586
78587   jresult = result;
78588   return jresult;
78589 }
78590
78591
78592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78593   float jresult ;
78594   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78595   float arg2 ;
78596   float result;
78597
78598   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78599   arg2 = (float)jarg2;
78600   {
78601     try {
78602       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78603     } catch (std::out_of_range& e) {
78604       {
78605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78606       };
78607     } catch (std::exception& e) {
78608       {
78609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78610       };
78611     } catch (Dali::DaliException e) {
78612       {
78613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78614       };
78615     } catch (...) {
78616       {
78617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78618       };
78619     }
78620   }
78621
78622   jresult = result;
78623   return jresult;
78624 }
78625
78626
78627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78628   float jresult ;
78629   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78630   unsigned int arg2 ;
78631   unsigned int *arg3 = 0 ;
78632   bool arg4 ;
78633   float result;
78634
78635   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78636   arg2 = (unsigned int)jarg2;
78637   arg3 = (unsigned int *)jarg3;
78638   arg4 = jarg4 ? true : false;
78639   {
78640     try {
78641       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78642     } catch (std::out_of_range& e) {
78643       {
78644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78645       };
78646     } catch (std::exception& e) {
78647       {
78648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78649       };
78650     } catch (Dali::DaliException e) {
78651       {
78652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78653       };
78654     } catch (...) {
78655       {
78656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78657       };
78658     }
78659   }
78660
78661   jresult = result;
78662   return jresult;
78663 }
78664
78665
78666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78667   unsigned int jresult ;
78668   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78669   float arg2 ;
78670   bool arg3 ;
78671   unsigned int result;
78672
78673   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78674   arg2 = (float)jarg2;
78675   arg3 = jarg3 ? true : false;
78676   {
78677     try {
78678       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78679     } catch (std::out_of_range& e) {
78680       {
78681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78682       };
78683     } catch (std::exception& e) {
78684       {
78685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78686       };
78687     } catch (Dali::DaliException e) {
78688       {
78689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78690       };
78691     } catch (...) {
78692       {
78693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78694       };
78695     }
78696   }
78697
78698   jresult = result;
78699   return jresult;
78700 }
78701
78702
78703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78704   unsigned int jresult ;
78705   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78706   unsigned int result;
78707
78708   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78709   {
78710     try {
78711       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78712     } catch (std::out_of_range& e) {
78713       {
78714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78715       };
78716     } catch (std::exception& e) {
78717       {
78718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78719       };
78720     } catch (Dali::DaliException e) {
78721       {
78722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78723       };
78724     } catch (...) {
78725       {
78726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78727       };
78728     }
78729   }
78730
78731   jresult = result;
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78737   int jresult ;
78738   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78739   Dali::Toolkit::Ruler::RulerType result;
78740
78741   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78742   {
78743     try {
78744       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78745     } catch (std::out_of_range& e) {
78746       {
78747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78748       };
78749     } catch (std::exception& e) {
78750       {
78751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78752       };
78753     } catch (Dali::DaliException e) {
78754       {
78755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78756       };
78757     } catch (...) {
78758       {
78759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78760       };
78761     }
78762   }
78763
78764   jresult = (int)result;
78765   return jresult;
78766 }
78767
78768
78769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78770   unsigned int jresult ;
78771   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78772   bool result;
78773
78774   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78775   {
78776     try {
78777       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78778     } catch (std::out_of_range& e) {
78779       {
78780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78781       };
78782     } catch (std::exception& e) {
78783       {
78784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78785       };
78786     } catch (Dali::DaliException e) {
78787       {
78788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78789       };
78790     } catch (...) {
78791       {
78792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78793       };
78794     }
78795   }
78796
78797   jresult = result;
78798   return jresult;
78799 }
78800
78801
78802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78803   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78804
78805   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78806   {
78807     try {
78808       (arg1)->Enable();
78809     } catch (std::out_of_range& e) {
78810       {
78811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78812       };
78813     } catch (std::exception& e) {
78814       {
78815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78816       };
78817     } catch (Dali::DaliException e) {
78818       {
78819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78820       };
78821     } catch (...) {
78822       {
78823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78824       };
78825     }
78826   }
78827
78828 }
78829
78830
78831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78832   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78833
78834   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78835   {
78836     try {
78837       (arg1)->Disable();
78838     } catch (std::out_of_range& e) {
78839       {
78840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78841       };
78842     } catch (std::exception& e) {
78843       {
78844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78845       };
78846     } catch (Dali::DaliException e) {
78847       {
78848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78849       };
78850     } catch (...) {
78851       {
78852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78853       };
78854     }
78855   }
78856
78857 }
78858
78859
78860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78861   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78862   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78863   Dali::Toolkit::RulerDomain *argp2 ;
78864
78865   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78866   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78867   if (!argp2) {
78868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78869     return ;
78870   }
78871   arg2 = *argp2;
78872   {
78873     try {
78874       (arg1)->SetDomain(arg2);
78875     } catch (std::out_of_range& e) {
78876       {
78877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78878       };
78879     } catch (std::exception& e) {
78880       {
78881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78882       };
78883     } catch (Dali::DaliException e) {
78884       {
78885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78886       };
78887     } catch (...) {
78888       {
78889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78890       };
78891     }
78892   }
78893
78894 }
78895
78896
78897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78898   void * jresult ;
78899   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78900   Dali::Toolkit::RulerDomain *result = 0 ;
78901
78902   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78903   {
78904     try {
78905       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78906     } catch (std::out_of_range& e) {
78907       {
78908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78909       };
78910     } catch (std::exception& e) {
78911       {
78912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78913       };
78914     } catch (Dali::DaliException e) {
78915       {
78916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78917       };
78918     } catch (...) {
78919       {
78920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78921       };
78922     }
78923   }
78924
78925   jresult = (void *)result;
78926   return jresult;
78927 }
78928
78929
78930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78931   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78932
78933   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78934   {
78935     try {
78936       (arg1)->DisableDomain();
78937     } catch (std::out_of_range& e) {
78938       {
78939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78940       };
78941     } catch (std::exception& e) {
78942       {
78943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78944       };
78945     } catch (Dali::DaliException e) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78948       };
78949     } catch (...) {
78950       {
78951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78952       };
78953     }
78954   }
78955
78956 }
78957
78958
78959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78960   float jresult ;
78961   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78962   float arg2 ;
78963   float arg3 ;
78964   float arg4 ;
78965   float result;
78966
78967   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78968   arg2 = (float)jarg2;
78969   arg3 = (float)jarg3;
78970   arg4 = (float)jarg4;
78971   {
78972     try {
78973       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78974     } catch (std::out_of_range& e) {
78975       {
78976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78977       };
78978     } catch (std::exception& e) {
78979       {
78980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78981       };
78982     } catch (Dali::DaliException e) {
78983       {
78984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78985       };
78986     } catch (...) {
78987       {
78988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78989       };
78990     }
78991   }
78992
78993   jresult = result;
78994   return jresult;
78995 }
78996
78997
78998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78999   float jresult ;
79000   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79001   float arg2 ;
79002   float arg3 ;
79003   float result;
79004
79005   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79006   arg2 = (float)jarg2;
79007   arg3 = (float)jarg3;
79008   {
79009     try {
79010       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
79011     } catch (std::out_of_range& e) {
79012       {
79013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79014       };
79015     } catch (std::exception& e) {
79016       {
79017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79018       };
79019     } catch (Dali::DaliException e) {
79020       {
79021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79022       };
79023     } catch (...) {
79024       {
79025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79026       };
79027     }
79028   }
79029
79030   jresult = result;
79031   return jresult;
79032 }
79033
79034
79035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79036   float jresult ;
79037   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79038   float arg2 ;
79039   float result;
79040
79041   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79042   arg2 = (float)jarg2;
79043   {
79044     try {
79045       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79046     } catch (std::out_of_range& e) {
79047       {
79048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79049       };
79050     } catch (std::exception& e) {
79051       {
79052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79053       };
79054     } catch (Dali::DaliException e) {
79055       {
79056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79057       };
79058     } catch (...) {
79059       {
79060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79061       };
79062     }
79063   }
79064
79065   jresult = result;
79066   return jresult;
79067 }
79068
79069
79070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79071   float jresult ;
79072   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79073   float arg2 ;
79074   float arg3 ;
79075   float arg4 ;
79076   Dali::Toolkit::ClampState *arg5 = 0 ;
79077   float result;
79078
79079   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79080   arg2 = (float)jarg2;
79081   arg3 = (float)jarg3;
79082   arg4 = (float)jarg4;
79083   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79084   if (!arg5) {
79085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79086     return 0;
79087   }
79088   {
79089     try {
79090       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79091     } catch (std::out_of_range& e) {
79092       {
79093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (std::exception& e) {
79096       {
79097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79098       };
79099     } catch (Dali::DaliException e) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79102       };
79103     } catch (...) {
79104       {
79105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79106       };
79107     }
79108   }
79109
79110   jresult = result;
79111   return jresult;
79112 }
79113
79114
79115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79116   float jresult ;
79117   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79118   float arg2 ;
79119   float arg3 ;
79120   float arg4 ;
79121   float arg5 ;
79122   float result;
79123
79124   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79125   arg2 = (float)jarg2;
79126   arg3 = (float)jarg3;
79127   arg4 = (float)jarg4;
79128   arg5 = (float)jarg5;
79129   {
79130     try {
79131       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79132     } catch (std::out_of_range& e) {
79133       {
79134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79135       };
79136     } catch (std::exception& e) {
79137       {
79138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79139       };
79140     } catch (Dali::DaliException e) {
79141       {
79142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79143       };
79144     } catch (...) {
79145       {
79146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79147       };
79148     }
79149   }
79150
79151   jresult = result;
79152   return jresult;
79153 }
79154
79155
79156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79157   float jresult ;
79158   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79159   float arg2 ;
79160   float arg3 ;
79161   float arg4 ;
79162   float result;
79163
79164   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79165   arg2 = (float)jarg2;
79166   arg3 = (float)jarg3;
79167   arg4 = (float)jarg4;
79168   {
79169     try {
79170       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79171     } catch (std::out_of_range& e) {
79172       {
79173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79174       };
79175     } catch (std::exception& e) {
79176       {
79177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79178       };
79179     } catch (Dali::DaliException e) {
79180       {
79181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79182       };
79183     } catch (...) {
79184       {
79185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79186       };
79187     }
79188   }
79189
79190   jresult = result;
79191   return jresult;
79192 }
79193
79194
79195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79196   float jresult ;
79197   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79198   float arg2 ;
79199   float arg3 ;
79200   float result;
79201
79202   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79203   arg2 = (float)jarg2;
79204   arg3 = (float)jarg3;
79205   {
79206     try {
79207       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79208     } catch (std::out_of_range& e) {
79209       {
79210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79211       };
79212     } catch (std::exception& e) {
79213       {
79214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79215       };
79216     } catch (Dali::DaliException e) {
79217       {
79218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79219       };
79220     } catch (...) {
79221       {
79222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79223       };
79224     }
79225   }
79226
79227   jresult = result;
79228   return jresult;
79229 }
79230
79231
79232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79233   float jresult ;
79234   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79235   float arg2 ;
79236   float result;
79237
79238   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79239   arg2 = (float)jarg2;
79240   {
79241     try {
79242       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79243     } catch (std::out_of_range& e) {
79244       {
79245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79246       };
79247     } catch (std::exception& e) {
79248       {
79249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79250       };
79251     } catch (Dali::DaliException e) {
79252       {
79253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79254       };
79255     } catch (...) {
79256       {
79257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79258       };
79259     }
79260   }
79261
79262   jresult = result;
79263   return jresult;
79264 }
79265
79266
79267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79268   float jresult ;
79269   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79270   float arg2 ;
79271   float arg3 ;
79272   float arg4 ;
79273   float arg5 ;
79274   Dali::Toolkit::ClampState *arg6 = 0 ;
79275   float result;
79276
79277   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79278   arg2 = (float)jarg2;
79279   arg3 = (float)jarg3;
79280   arg4 = (float)jarg4;
79281   arg5 = (float)jarg5;
79282   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79283   if (!arg6) {
79284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79285     return 0;
79286   }
79287   {
79288     try {
79289       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79290     } catch (std::out_of_range& e) {
79291       {
79292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79293       };
79294     } catch (std::exception& e) {
79295       {
79296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79297       };
79298     } catch (Dali::DaliException e) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79301       };
79302     } catch (...) {
79303       {
79304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79305       };
79306     }
79307   }
79308
79309   jresult = result;
79310   return jresult;
79311 }
79312
79313
79314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79315   void * jresult ;
79316   Dali::Toolkit::DefaultRuler *result = 0 ;
79317
79318   {
79319     try {
79320       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79321     } catch (std::out_of_range& e) {
79322       {
79323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79324       };
79325     } catch (std::exception& e) {
79326       {
79327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79328       };
79329     } catch (Dali::DaliException e) {
79330       {
79331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79332       };
79333     } catch (...) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79336       };
79337     }
79338   }
79339
79340   jresult = (void *)result;
79341   return jresult;
79342 }
79343
79344
79345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79346   float jresult ;
79347   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79348   float arg2 ;
79349   float arg3 ;
79350   float result;
79351
79352   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79353   arg2 = (float)jarg2;
79354   arg3 = (float)jarg3;
79355   {
79356     try {
79357       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79358     } catch (std::out_of_range& e) {
79359       {
79360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79361       };
79362     } catch (std::exception& e) {
79363       {
79364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79365       };
79366     } catch (Dali::DaliException e) {
79367       {
79368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79369       };
79370     } catch (...) {
79371       {
79372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79373       };
79374     }
79375   }
79376
79377   jresult = result;
79378   return jresult;
79379 }
79380
79381
79382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79383   float jresult ;
79384   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79385   unsigned int arg2 ;
79386   unsigned int *arg3 = 0 ;
79387   bool arg4 ;
79388   float result;
79389
79390   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79391   arg2 = (unsigned int)jarg2;
79392   arg3 = (unsigned int *)jarg3;
79393   arg4 = jarg4 ? true : false;
79394   {
79395     try {
79396       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79397     } catch (std::out_of_range& e) {
79398       {
79399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79400       };
79401     } catch (std::exception& e) {
79402       {
79403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79404       };
79405     } catch (Dali::DaliException e) {
79406       {
79407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79408       };
79409     } catch (...) {
79410       {
79411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79412       };
79413     }
79414   }
79415
79416   jresult = result;
79417   return jresult;
79418 }
79419
79420
79421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79422   unsigned int jresult ;
79423   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79424   float arg2 ;
79425   bool arg3 ;
79426   unsigned int result;
79427
79428   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79429   arg2 = (float)jarg2;
79430   arg3 = jarg3 ? true : false;
79431   {
79432     try {
79433       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79434     } catch (std::out_of_range& e) {
79435       {
79436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79437       };
79438     } catch (std::exception& e) {
79439       {
79440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79441       };
79442     } catch (Dali::DaliException e) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79445       };
79446     } catch (...) {
79447       {
79448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79449       };
79450     }
79451   }
79452
79453   jresult = result;
79454   return jresult;
79455 }
79456
79457
79458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79459   unsigned int jresult ;
79460   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79461   unsigned int result;
79462
79463   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79464   {
79465     try {
79466       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79467     } catch (std::out_of_range& e) {
79468       {
79469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79470       };
79471     } catch (std::exception& e) {
79472       {
79473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79474       };
79475     } catch (Dali::DaliException e) {
79476       {
79477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79478       };
79479     } catch (...) {
79480       {
79481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79482       };
79483     }
79484   }
79485
79486   jresult = result;
79487   return jresult;
79488 }
79489
79490
79491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79492   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79493
79494   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79495   {
79496     try {
79497       delete arg1;
79498     } catch (std::out_of_range& e) {
79499       {
79500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79501       };
79502     } catch (std::exception& e) {
79503       {
79504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79505       };
79506     } catch (Dali::DaliException e) {
79507       {
79508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79509       };
79510     } catch (...) {
79511       {
79512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79513       };
79514     }
79515   }
79516
79517 }
79518
79519
79520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79521   void * jresult ;
79522   float arg1 ;
79523   Dali::Toolkit::FixedRuler *result = 0 ;
79524
79525   arg1 = (float)jarg1;
79526   {
79527     try {
79528       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79529     } catch (std::out_of_range& e) {
79530       {
79531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79532       };
79533     } catch (std::exception& e) {
79534       {
79535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79536       };
79537     } catch (Dali::DaliException e) {
79538       {
79539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79540       };
79541     } catch (...) {
79542       {
79543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79544       };
79545     }
79546   }
79547
79548   jresult = (void *)result;
79549   return jresult;
79550 }
79551
79552
79553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79554   void * jresult ;
79555   Dali::Toolkit::FixedRuler *result = 0 ;
79556
79557   {
79558     try {
79559       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79560     } catch (std::out_of_range& e) {
79561       {
79562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79563       };
79564     } catch (std::exception& e) {
79565       {
79566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79567       };
79568     } catch (Dali::DaliException e) {
79569       {
79570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79571       };
79572     } catch (...) {
79573       {
79574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79575       };
79576     }
79577   }
79578
79579   jresult = (void *)result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79585   float jresult ;
79586   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79587   float arg2 ;
79588   float arg3 ;
79589   float result;
79590
79591   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79592   arg2 = (float)jarg2;
79593   arg3 = (float)jarg3;
79594   {
79595     try {
79596       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79597     } catch (std::out_of_range& e) {
79598       {
79599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79600       };
79601     } catch (std::exception& e) {
79602       {
79603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79604       };
79605     } catch (Dali::DaliException e) {
79606       {
79607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79608       };
79609     } catch (...) {
79610       {
79611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79612       };
79613     }
79614   }
79615
79616   jresult = result;
79617   return jresult;
79618 }
79619
79620
79621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79622   float jresult ;
79623   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79624   unsigned int arg2 ;
79625   unsigned int *arg3 = 0 ;
79626   bool arg4 ;
79627   float result;
79628
79629   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79630   arg2 = (unsigned int)jarg2;
79631   arg3 = (unsigned int *)jarg3;
79632   arg4 = jarg4 ? true : false;
79633   {
79634     try {
79635       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79636     } catch (std::out_of_range& e) {
79637       {
79638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79639       };
79640     } catch (std::exception& e) {
79641       {
79642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79643       };
79644     } catch (Dali::DaliException e) {
79645       {
79646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79647       };
79648     } catch (...) {
79649       {
79650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79651       };
79652     }
79653   }
79654
79655   jresult = result;
79656   return jresult;
79657 }
79658
79659
79660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79661   unsigned int jresult ;
79662   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79663   float arg2 ;
79664   bool arg3 ;
79665   unsigned int result;
79666
79667   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79668   arg2 = (float)jarg2;
79669   arg3 = jarg3 ? true : false;
79670   {
79671     try {
79672       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79673     } catch (std::out_of_range& e) {
79674       {
79675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (std::exception& e) {
79678       {
79679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79680       };
79681     } catch (Dali::DaliException e) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79684       };
79685     } catch (...) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79688       };
79689     }
79690   }
79691
79692   jresult = result;
79693   return jresult;
79694 }
79695
79696
79697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79698   unsigned int jresult ;
79699   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79700   unsigned int result;
79701
79702   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79703   {
79704     try {
79705       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79706     } catch (std::out_of_range& e) {
79707       {
79708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79709       };
79710     } catch (std::exception& e) {
79711       {
79712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79713       };
79714     } catch (Dali::DaliException e) {
79715       {
79716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79717       };
79718     } catch (...) {
79719       {
79720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79721       };
79722     }
79723   }
79724
79725   jresult = result;
79726   return jresult;
79727 }
79728
79729
79730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79731   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79732
79733   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79734   {
79735     try {
79736       delete arg1;
79737     } catch (std::out_of_range& e) {
79738       {
79739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79740       };
79741     } catch (std::exception& e) {
79742       {
79743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79744       };
79745     } catch (Dali::DaliException e) {
79746       {
79747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79748       };
79749     } catch (...) {
79750       {
79751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79752       };
79753     }
79754   }
79755
79756 }
79757
79758
79759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79760   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79761   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79762
79763   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79764   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79765   if (arg1) (arg1)->scale = *arg2;
79766 }
79767
79768
79769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79770   void * jresult ;
79771   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79772   Dali::Toolkit::ClampState2D *result = 0 ;
79773
79774   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79775   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79776   jresult = (void *)result;
79777   return jresult;
79778 }
79779
79780
79781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79782   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79783   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79784
79785   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79786   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79787   if (arg1) (arg1)->position = *arg2;
79788 }
79789
79790
79791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79792   void * jresult ;
79793   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79794   Dali::Toolkit::ClampState2D *result = 0 ;
79795
79796   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79797   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79798   jresult = (void *)result;
79799   return jresult;
79800 }
79801
79802
79803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79804   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79805   Dali::Toolkit::ClampState arg2 ;
79806
79807   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79808   arg2 = (Dali::Toolkit::ClampState)jarg2;
79809   if (arg1) (arg1)->rotation = arg2;
79810 }
79811
79812
79813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79814   int jresult ;
79815   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79816   Dali::Toolkit::ClampState result;
79817
79818   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79819   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79820   jresult = (int)result;
79821   return jresult;
79822 }
79823
79824
79825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79826   void * jresult ;
79827   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79828
79829   {
79830     try {
79831       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79832     } catch (std::out_of_range& e) {
79833       {
79834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79835       };
79836     } catch (std::exception& e) {
79837       {
79838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79839       };
79840     } catch (Dali::DaliException e) {
79841       {
79842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79843       };
79844     } catch (...) {
79845       {
79846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79847       };
79848     }
79849   }
79850
79851   jresult = (void *)result;
79852   return jresult;
79853 }
79854
79855
79856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79857   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79858
79859   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79860   {
79861     try {
79862       delete arg1;
79863     } catch (std::out_of_range& e) {
79864       {
79865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79866       };
79867     } catch (std::exception& e) {
79868       {
79869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79870       };
79871     } catch (Dali::DaliException e) {
79872       {
79873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79874       };
79875     } catch (...) {
79876       {
79877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79878       };
79879     }
79880   }
79881
79882 }
79883
79884
79885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79886   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79887   Dali::Toolkit::SnapType arg2 ;
79888
79889   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79890   arg2 = (Dali::Toolkit::SnapType)jarg2;
79891   if (arg1) (arg1)->type = arg2;
79892 }
79893
79894
79895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79896   int jresult ;
79897   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79898   Dali::Toolkit::SnapType result;
79899
79900   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79901   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79902   jresult = (int)result;
79903   return jresult;
79904 }
79905
79906
79907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79908   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79909   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79910
79911   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79912   arg2 = (Dali::Vector2 *)jarg2;
79913   if (arg1) (arg1)->position = *arg2;
79914 }
79915
79916
79917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79918   void * jresult ;
79919   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79920   Dali::Vector2 *result = 0 ;
79921
79922   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79923   result = (Dali::Vector2 *)& ((arg1)->position);
79924   jresult = (void *)result;
79925   return jresult;
79926 }
79927
79928
79929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79930   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79931   float arg2 ;
79932
79933   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79934   arg2 = (float)jarg2;
79935   if (arg1) (arg1)->duration = arg2;
79936 }
79937
79938
79939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79940   float jresult ;
79941   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79942   float result;
79943
79944   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79945   result = (float) ((arg1)->duration);
79946   jresult = result;
79947   return jresult;
79948 }
79949
79950
79951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79952   void * jresult ;
79953   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79954
79955   {
79956     try {
79957       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79958     } catch (std::out_of_range& e) {
79959       {
79960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79961       };
79962     } catch (std::exception& e) {
79963       {
79964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79965       };
79966     } catch (Dali::DaliException e) {
79967       {
79968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79969       };
79970     } catch (...) {
79971       {
79972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79973       };
79974     }
79975   }
79976
79977   jresult = (void *)result;
79978   return jresult;
79979 }
79980
79981
79982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79983   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79984
79985   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79986   {
79987     try {
79988       delete arg1;
79989     } catch (std::out_of_range& e) {
79990       {
79991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79992       };
79993     } catch (std::exception& e) {
79994       {
79995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79996       };
79997     } catch (Dali::DaliException e) {
79998       {
79999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80000       };
80001     } catch (...) {
80002       {
80003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80004       };
80005     }
80006   }
80007
80008 }
80009
80010
80011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80012   int jresult ;
80013   int result;
80014
80015   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80016   jresult = (int)result;
80017   return jresult;
80018 }
80019
80020
80021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80022   int jresult ;
80023   int result;
80024
80025   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80026   jresult = (int)result;
80027   return jresult;
80028 }
80029
80030
80031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80032   int jresult ;
80033   int result;
80034
80035   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80036   jresult = (int)result;
80037   return jresult;
80038 }
80039
80040
80041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80042   int jresult ;
80043   int result;
80044
80045   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80046   jresult = (int)result;
80047   return jresult;
80048 }
80049
80050
80051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80052   int jresult ;
80053   int result;
80054
80055   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80056   jresult = (int)result;
80057   return jresult;
80058 }
80059
80060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80061   int jresult ;
80062   int result;
80063
80064   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80065   jresult = (int)result;
80066   return jresult;
80067 }
80068
80069
80070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80071   int jresult ;
80072   int result;
80073
80074   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80075   jresult = (int)result;
80076   return jresult;
80077 }
80078
80079
80080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80081   int jresult ;
80082   int result;
80083
80084   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80085   jresult = (int)result;
80086   return jresult;
80087 }
80088
80089
80090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80091   int jresult ;
80092   int result;
80093
80094   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80095   jresult = (int)result;
80096   return jresult;
80097 }
80098
80099
80100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80101   int jresult ;
80102   int result;
80103
80104   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80105   jresult = (int)result;
80106   return jresult;
80107 }
80108
80109
80110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80111   int jresult ;
80112   int result;
80113
80114   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80115   jresult = (int)result;
80116   return jresult;
80117 }
80118
80119
80120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80121   int jresult ;
80122   int result;
80123
80124   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80125   jresult = (int)result;
80126   return jresult;
80127 }
80128
80129
80130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80131   int jresult ;
80132   int result;
80133
80134   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80135   jresult = (int)result;
80136   return jresult;
80137 }
80138
80139
80140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80141   int jresult ;
80142   int result;
80143
80144   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80145   jresult = (int)result;
80146   return jresult;
80147 }
80148
80149
80150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80151   int jresult ;
80152   int result;
80153
80154   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80155   jresult = (int)result;
80156   return jresult;
80157 }
80158
80159
80160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80161   int jresult ;
80162   int result;
80163
80164   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80165   jresult = (int)result;
80166   return jresult;
80167 }
80168
80169
80170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80171   int jresult ;
80172   int result;
80173
80174   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80175   jresult = (int)result;
80176   return jresult;
80177 }
80178
80179
80180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80181   int jresult ;
80182   int result;
80183
80184   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80185   jresult = (int)result;
80186   return jresult;
80187 }
80188
80189
80190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80191   int jresult ;
80192   int result;
80193
80194   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80195   jresult = (int)result;
80196   return jresult;
80197 }
80198
80199
80200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80201   int jresult ;
80202   int result;
80203
80204   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80205   jresult = (int)result;
80206   return jresult;
80207 }
80208
80209
80210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80211   int jresult ;
80212   int result;
80213
80214   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80215   jresult = (int)result;
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80221   int jresult ;
80222   int result;
80223
80224   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80225   jresult = (int)result;
80226   return jresult;
80227 }
80228
80229
80230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80231   int jresult ;
80232   int result;
80233
80234   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80235   jresult = (int)result;
80236   return jresult;
80237 }
80238
80239
80240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80241   int jresult ;
80242   int result;
80243
80244   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80245   jresult = (int)result;
80246   return jresult;
80247 }
80248
80249
80250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80251   int jresult ;
80252   int result;
80253
80254   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80255   jresult = (int)result;
80256   return jresult;
80257 }
80258
80259
80260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80261   int jresult ;
80262   int result;
80263
80264   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80265   jresult = (int)result;
80266   return jresult;
80267 }
80268
80269
80270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80271   void * jresult ;
80272   Dali::Toolkit::ScrollView::Property *result = 0 ;
80273
80274   {
80275     try {
80276       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80277     } catch (std::out_of_range& e) {
80278       {
80279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80280       };
80281     } catch (std::exception& e) {
80282       {
80283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80284       };
80285     } catch (Dali::DaliException e) {
80286       {
80287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80288       };
80289     } catch (...) {
80290       {
80291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80292       };
80293     }
80294   }
80295
80296   jresult = (void *)result;
80297   return jresult;
80298 }
80299
80300
80301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80302   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80303
80304   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80305   {
80306     try {
80307       delete arg1;
80308     } catch (std::out_of_range& e) {
80309       {
80310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80311       };
80312     } catch (std::exception& e) {
80313       {
80314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80315       };
80316     } catch (Dali::DaliException e) {
80317       {
80318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80319       };
80320     } catch (...) {
80321       {
80322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80323       };
80324     }
80325   }
80326
80327 }
80328
80329
80330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80331   void * jresult ;
80332   Dali::Toolkit::ScrollView *result = 0 ;
80333
80334   {
80335     try {
80336       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80337     } catch (std::out_of_range& e) {
80338       {
80339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80340       };
80341     } catch (std::exception& e) {
80342       {
80343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80344       };
80345     } catch (Dali::DaliException e) {
80346       {
80347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80348       };
80349     } catch (...) {
80350       {
80351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80352       };
80353     }
80354   }
80355
80356   jresult = (void *)result;
80357   return jresult;
80358 }
80359
80360
80361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80362   void * jresult ;
80363   Dali::Toolkit::ScrollView *arg1 = 0 ;
80364   Dali::Toolkit::ScrollView *result = 0 ;
80365
80366   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80367   if (!arg1) {
80368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80369     return 0;
80370   }
80371   {
80372     try {
80373       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80374     } catch (std::out_of_range& e) {
80375       {
80376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80377       };
80378     } catch (std::exception& e) {
80379       {
80380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80381       };
80382     } catch (Dali::DaliException e) {
80383       {
80384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80385       };
80386     } catch (...) {
80387       {
80388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80389       };
80390     }
80391   }
80392
80393   jresult = (void *)result;
80394   return jresult;
80395 }
80396
80397
80398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80399   void * jresult ;
80400   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80401   Dali::Toolkit::ScrollView *arg2 = 0 ;
80402   Dali::Toolkit::ScrollView *result = 0 ;
80403
80404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80405   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80406   if (!arg2) {
80407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80408     return 0;
80409   }
80410   {
80411     try {
80412       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80413     } catch (std::out_of_range& e) {
80414       {
80415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80416       };
80417     } catch (std::exception& e) {
80418       {
80419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80420       };
80421     } catch (Dali::DaliException e) {
80422       {
80423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80424       };
80425     } catch (...) {
80426       {
80427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80428       };
80429     }
80430   }
80431
80432   jresult = (void *)result;
80433   return jresult;
80434 }
80435
80436
80437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80438   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80439
80440   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80441   {
80442     try {
80443       delete arg1;
80444     } catch (std::out_of_range& e) {
80445       {
80446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80447       };
80448     } catch (std::exception& e) {
80449       {
80450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80451       };
80452     } catch (Dali::DaliException e) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80455       };
80456     } catch (...) {
80457       {
80458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80459       };
80460     }
80461   }
80462
80463 }
80464
80465
80466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80467   void * jresult ;
80468   Dali::Toolkit::ScrollView result;
80469
80470   {
80471     try {
80472       result = Dali::Toolkit::ScrollView::New();
80473     } catch (std::out_of_range& e) {
80474       {
80475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80476       };
80477     } catch (std::exception& e) {
80478       {
80479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80480       };
80481     } catch (Dali::DaliException e) {
80482       {
80483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80484       };
80485     } catch (...) {
80486       {
80487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80488       };
80489     }
80490   }
80491
80492   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80493   return jresult;
80494 }
80495
80496
80497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80498   void * jresult ;
80499   Dali::BaseHandle arg1 ;
80500   Dali::BaseHandle *argp1 ;
80501   Dali::Toolkit::ScrollView result;
80502
80503   argp1 = (Dali::BaseHandle *)jarg1;
80504   if (!argp1) {
80505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80506     return 0;
80507   }
80508   arg1 = *argp1;
80509   {
80510     try {
80511       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80512     } catch (std::out_of_range& e) {
80513       {
80514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80515       };
80516     } catch (std::exception& e) {
80517       {
80518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80519       };
80520     } catch (Dali::DaliException e) {
80521       {
80522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80523       };
80524     } catch (...) {
80525       {
80526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80527       };
80528     }
80529   }
80530
80531   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80532   return jresult;
80533 }
80534
80535
80536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80537   void * jresult ;
80538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80539   Dali::AlphaFunction result;
80540
80541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80542   {
80543     try {
80544       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80545     } catch (std::out_of_range& e) {
80546       {
80547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80548       };
80549     } catch (std::exception& e) {
80550       {
80551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80552       };
80553     } catch (Dali::DaliException e) {
80554       {
80555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80556       };
80557     } catch (...) {
80558       {
80559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80560       };
80561     }
80562   }
80563
80564   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80565   return jresult;
80566 }
80567
80568
80569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80570   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80571   Dali::AlphaFunction arg2 ;
80572   Dali::AlphaFunction *argp2 ;
80573
80574   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80575   argp2 = (Dali::AlphaFunction *)jarg2;
80576   if (!argp2) {
80577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80578     return ;
80579   }
80580   arg2 = *argp2;
80581   {
80582     try {
80583       (arg1)->SetScrollSnapAlphaFunction(arg2);
80584     } catch (std::out_of_range& e) {
80585       {
80586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80587       };
80588     } catch (std::exception& e) {
80589       {
80590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80591       };
80592     } catch (Dali::DaliException e) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80595       };
80596     } catch (...) {
80597       {
80598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80599       };
80600     }
80601   }
80602
80603 }
80604
80605
80606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80607   void * jresult ;
80608   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80609   Dali::AlphaFunction result;
80610
80611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80612   {
80613     try {
80614       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80615     } catch (std::out_of_range& e) {
80616       {
80617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80618       };
80619     } catch (std::exception& e) {
80620       {
80621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80622       };
80623     } catch (Dali::DaliException e) {
80624       {
80625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80626       };
80627     } catch (...) {
80628       {
80629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80630       };
80631     }
80632   }
80633
80634   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80635   return jresult;
80636 }
80637
80638
80639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80640   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80641   Dali::AlphaFunction arg2 ;
80642   Dali::AlphaFunction *argp2 ;
80643
80644   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80645   argp2 = (Dali::AlphaFunction *)jarg2;
80646   if (!argp2) {
80647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80648     return ;
80649   }
80650   arg2 = *argp2;
80651   {
80652     try {
80653       (arg1)->SetScrollFlickAlphaFunction(arg2);
80654     } catch (std::out_of_range& e) {
80655       {
80656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80657       };
80658     } catch (std::exception& e) {
80659       {
80660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80661       };
80662     } catch (Dali::DaliException e) {
80663       {
80664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80665       };
80666     } catch (...) {
80667       {
80668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80669       };
80670     }
80671   }
80672
80673 }
80674
80675
80676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80677   float jresult ;
80678   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80679   float result;
80680
80681   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80682   {
80683     try {
80684       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80685     } catch (std::out_of_range& e) {
80686       {
80687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80688       };
80689     } catch (std::exception& e) {
80690       {
80691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80692       };
80693     } catch (Dali::DaliException e) {
80694       {
80695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80696       };
80697     } catch (...) {
80698       {
80699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80700       };
80701     }
80702   }
80703
80704   jresult = result;
80705   return jresult;
80706 }
80707
80708
80709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80710   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80711   float arg2 ;
80712
80713   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80714   arg2 = (float)jarg2;
80715   {
80716     try {
80717       (arg1)->SetScrollSnapDuration(arg2);
80718     } catch (std::out_of_range& e) {
80719       {
80720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80721       };
80722     } catch (std::exception& e) {
80723       {
80724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80725       };
80726     } catch (Dali::DaliException e) {
80727       {
80728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80729       };
80730     } catch (...) {
80731       {
80732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80733       };
80734     }
80735   }
80736
80737 }
80738
80739
80740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80741   float jresult ;
80742   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80743   float result;
80744
80745   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80746   {
80747     try {
80748       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80749     } catch (std::out_of_range& e) {
80750       {
80751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80752       };
80753     } catch (std::exception& e) {
80754       {
80755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80756       };
80757     } catch (Dali::DaliException e) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80760       };
80761     } catch (...) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80764       };
80765     }
80766   }
80767
80768   jresult = result;
80769   return jresult;
80770 }
80771
80772
80773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80775   float arg2 ;
80776
80777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80778   arg2 = (float)jarg2;
80779   {
80780     try {
80781       (arg1)->SetScrollFlickDuration(arg2);
80782     } catch (std::out_of_range& e) {
80783       {
80784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80785       };
80786     } catch (std::exception& e) {
80787       {
80788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80789       };
80790     } catch (Dali::DaliException e) {
80791       {
80792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80793       };
80794     } catch (...) {
80795       {
80796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80797       };
80798     }
80799   }
80800
80801 }
80802
80803
80804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80806   Dali::Toolkit::RulerPtr arg2 ;
80807   Dali::Toolkit::RulerPtr *argp2 ;
80808
80809   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80810   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80811   if (!argp2) {
80812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80813     return ;
80814   }
80815   arg2 = *argp2;
80816   {
80817     try {
80818       (arg1)->SetRulerX(arg2);
80819     } catch (std::out_of_range& e) {
80820       {
80821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80822       };
80823     } catch (std::exception& e) {
80824       {
80825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80826       };
80827     } catch (Dali::DaliException e) {
80828       {
80829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80830       };
80831     } catch (...) {
80832       {
80833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80834       };
80835     }
80836   }
80837
80838 }
80839
80840
80841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80843   Dali::Toolkit::RulerPtr arg2 ;
80844   Dali::Toolkit::RulerPtr *argp2 ;
80845
80846   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80847   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80848   if (!argp2) {
80849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80850     return ;
80851   }
80852   arg2 = *argp2;
80853   {
80854     try {
80855       (arg1)->SetRulerY(arg2);
80856     } catch (std::out_of_range& e) {
80857       {
80858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80859       };
80860     } catch (std::exception& e) {
80861       {
80862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80863       };
80864     } catch (Dali::DaliException e) {
80865       {
80866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80867       };
80868     } catch (...) {
80869       {
80870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80871       };
80872     }
80873   }
80874
80875 }
80876
80877
80878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80879   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80880   bool arg2 ;
80881
80882   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80883   arg2 = jarg2 ? true : false;
80884   {
80885     try {
80886       (arg1)->SetScrollSensitive(arg2);
80887     } catch (std::out_of_range& e) {
80888       {
80889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80890       };
80891     } catch (std::exception& e) {
80892       {
80893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80894       };
80895     } catch (Dali::DaliException e) {
80896       {
80897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80898       };
80899     } catch (...) {
80900       {
80901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80902       };
80903     }
80904   }
80905
80906 }
80907
80908
80909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80911   float arg2 ;
80912   float arg3 ;
80913
80914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80915   arg2 = (float)jarg2;
80916   arg3 = (float)jarg3;
80917   {
80918     try {
80919       (arg1)->SetMaxOvershoot(arg2,arg3);
80920     } catch (std::out_of_range& e) {
80921       {
80922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80923       };
80924     } catch (std::exception& e) {
80925       {
80926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80927       };
80928     } catch (Dali::DaliException e) {
80929       {
80930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80931       };
80932     } catch (...) {
80933       {
80934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80935       };
80936     }
80937   }
80938
80939 }
80940
80941
80942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80944   Dali::AlphaFunction arg2 ;
80945   Dali::AlphaFunction *argp2 ;
80946
80947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80948   argp2 = (Dali::AlphaFunction *)jarg2;
80949   if (!argp2) {
80950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80951     return ;
80952   }
80953   arg2 = *argp2;
80954   {
80955     try {
80956       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80957     } catch (std::out_of_range& e) {
80958       {
80959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80960       };
80961     } catch (std::exception& e) {
80962       {
80963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80964       };
80965     } catch (Dali::DaliException e) {
80966       {
80967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80968       };
80969     } catch (...) {
80970       {
80971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80972       };
80973     }
80974   }
80975
80976 }
80977
80978
80979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80980   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80981   float arg2 ;
80982
80983   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80984   arg2 = (float)jarg2;
80985   {
80986     try {
80987       (arg1)->SetSnapOvershootDuration(arg2);
80988     } catch (std::out_of_range& e) {
80989       {
80990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80991       };
80992     } catch (std::exception& e) {
80993       {
80994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80995       };
80996     } catch (Dali::DaliException e) {
80997       {
80998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80999       };
81000     } catch (...) {
81001       {
81002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81003       };
81004     }
81005   }
81006
81007 }
81008
81009
81010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81011   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81012   bool arg2 ;
81013
81014   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81015   arg2 = jarg2 ? true : false;
81016   {
81017     try {
81018       (arg1)->SetActorAutoSnap(arg2);
81019     } catch (std::out_of_range& e) {
81020       {
81021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81022       };
81023     } catch (std::exception& e) {
81024       {
81025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81026       };
81027     } catch (Dali::DaliException e) {
81028       {
81029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81030       };
81031     } catch (...) {
81032       {
81033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81034       };
81035     }
81036   }
81037
81038 }
81039
81040
81041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81043   bool arg2 ;
81044
81045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81046   arg2 = jarg2 ? true : false;
81047   {
81048     try {
81049       (arg1)->SetWrapMode(arg2);
81050     } catch (std::out_of_range& e) {
81051       {
81052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81053       };
81054     } catch (std::exception& e) {
81055       {
81056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81057       };
81058     } catch (Dali::DaliException e) {
81059       {
81060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81061       };
81062     } catch (...) {
81063       {
81064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81065       };
81066     }
81067   }
81068
81069 }
81070
81071
81072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81073   int jresult ;
81074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81075   int result;
81076
81077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81078   {
81079     try {
81080       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81081     } catch (std::out_of_range& e) {
81082       {
81083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81084       };
81085     } catch (std::exception& e) {
81086       {
81087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81088       };
81089     } catch (Dali::DaliException e) {
81090       {
81091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81092       };
81093     } catch (...) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81096       };
81097     }
81098   }
81099
81100   jresult = result;
81101   return jresult;
81102 }
81103
81104
81105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81107   int arg2 ;
81108
81109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81110   arg2 = (int)jarg2;
81111   {
81112     try {
81113       (arg1)->SetScrollUpdateDistance(arg2);
81114     } catch (std::out_of_range& e) {
81115       {
81116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81117       };
81118     } catch (std::exception& e) {
81119       {
81120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81121       };
81122     } catch (Dali::DaliException e) {
81123       {
81124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81125       };
81126     } catch (...) {
81127       {
81128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81129       };
81130     }
81131   }
81132
81133 }
81134
81135
81136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81137   unsigned int jresult ;
81138   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81139   bool result;
81140
81141   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81142   {
81143     try {
81144       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81145     } catch (std::out_of_range& e) {
81146       {
81147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81148       };
81149     } catch (std::exception& e) {
81150       {
81151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81152       };
81153     } catch (Dali::DaliException e) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81156       };
81157     } catch (...) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81160       };
81161     }
81162   }
81163
81164   jresult = result;
81165   return jresult;
81166 }
81167
81168
81169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81170   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81171   bool arg2 ;
81172
81173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81174   arg2 = jarg2 ? true : false;
81175   {
81176     try {
81177       (arg1)->SetAxisAutoLock(arg2);
81178     } catch (std::out_of_range& e) {
81179       {
81180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81181       };
81182     } catch (std::exception& e) {
81183       {
81184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81185       };
81186     } catch (Dali::DaliException e) {
81187       {
81188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81189       };
81190     } catch (...) {
81191       {
81192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81193       };
81194     }
81195   }
81196
81197 }
81198
81199
81200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81201   float jresult ;
81202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81203   float result;
81204
81205   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81206   {
81207     try {
81208       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81209     } catch (std::out_of_range& e) {
81210       {
81211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81212       };
81213     } catch (std::exception& e) {
81214       {
81215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81216       };
81217     } catch (Dali::DaliException e) {
81218       {
81219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81220       };
81221     } catch (...) {
81222       {
81223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81224       };
81225     }
81226   }
81227
81228   jresult = result;
81229   return jresult;
81230 }
81231
81232
81233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81234   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81235   float arg2 ;
81236
81237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81238   arg2 = (float)jarg2;
81239   {
81240     try {
81241       (arg1)->SetAxisAutoLockGradient(arg2);
81242     } catch (std::out_of_range& e) {
81243       {
81244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81245       };
81246     } catch (std::exception& e) {
81247       {
81248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81249       };
81250     } catch (Dali::DaliException e) {
81251       {
81252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81253       };
81254     } catch (...) {
81255       {
81256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81257       };
81258     }
81259   }
81260
81261 }
81262
81263
81264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81265   float jresult ;
81266   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81267   float result;
81268
81269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81270   {
81271     try {
81272       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81273     } catch (std::out_of_range& e) {
81274       {
81275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81276       };
81277     } catch (std::exception& e) {
81278       {
81279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81280       };
81281     } catch (Dali::DaliException e) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81284       };
81285     } catch (...) {
81286       {
81287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81288       };
81289     }
81290   }
81291
81292   jresult = result;
81293   return jresult;
81294 }
81295
81296
81297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81299   float arg2 ;
81300
81301   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81302   arg2 = (float)jarg2;
81303   {
81304     try {
81305       (arg1)->SetFrictionCoefficient(arg2);
81306     } catch (std::out_of_range& e) {
81307       {
81308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81309       };
81310     } catch (std::exception& e) {
81311       {
81312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81313       };
81314     } catch (Dali::DaliException e) {
81315       {
81316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81317       };
81318     } catch (...) {
81319       {
81320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81321       };
81322     }
81323   }
81324
81325 }
81326
81327
81328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81329   float jresult ;
81330   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81331   float result;
81332
81333   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81334   {
81335     try {
81336       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81337     } catch (std::out_of_range& e) {
81338       {
81339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81340       };
81341     } catch (std::exception& e) {
81342       {
81343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81344       };
81345     } catch (Dali::DaliException e) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81348       };
81349     } catch (...) {
81350       {
81351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81352       };
81353     }
81354   }
81355
81356   jresult = result;
81357   return jresult;
81358 }
81359
81360
81361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81362   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81363   float arg2 ;
81364
81365   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81366   arg2 = (float)jarg2;
81367   {
81368     try {
81369       (arg1)->SetFlickSpeedCoefficient(arg2);
81370     } catch (std::out_of_range& e) {
81371       {
81372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81373       };
81374     } catch (std::exception& e) {
81375       {
81376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81377       };
81378     } catch (Dali::DaliException e) {
81379       {
81380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81381       };
81382     } catch (...) {
81383       {
81384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81385       };
81386     }
81387   }
81388
81389 }
81390
81391
81392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81393   void * jresult ;
81394   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81395   Dali::Vector2 result;
81396
81397   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81398   {
81399     try {
81400       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81401     } catch (std::out_of_range& e) {
81402       {
81403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81404       };
81405     } catch (std::exception& e) {
81406       {
81407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81408       };
81409     } catch (Dali::DaliException e) {
81410       {
81411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81412       };
81413     } catch (...) {
81414       {
81415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81416       };
81417     }
81418   }
81419
81420   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81421   return jresult;
81422 }
81423
81424
81425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81426   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81427   Dali::Vector2 *arg2 = 0 ;
81428
81429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81430   arg2 = (Dali::Vector2 *)jarg2;
81431   if (!arg2) {
81432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81433     return ;
81434   }
81435   {
81436     try {
81437       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81438     } catch (std::out_of_range& e) {
81439       {
81440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81441       };
81442     } catch (std::exception& e) {
81443       {
81444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81445       };
81446     } catch (Dali::DaliException e) {
81447       {
81448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81449       };
81450     } catch (...) {
81451       {
81452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81453       };
81454     }
81455   }
81456
81457 }
81458
81459
81460 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81461   float jresult ;
81462   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81463   float result;
81464
81465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81466   {
81467     try {
81468       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81469     } catch (std::out_of_range& e) {
81470       {
81471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81472       };
81473     } catch (std::exception& e) {
81474       {
81475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81476       };
81477     } catch (Dali::DaliException e) {
81478       {
81479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81480       };
81481     } catch (...) {
81482       {
81483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81484       };
81485     }
81486   }
81487
81488   jresult = result;
81489   return jresult;
81490 }
81491
81492
81493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81495   float arg2 ;
81496
81497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81498   arg2 = (float)jarg2;
81499   {
81500     try {
81501       (arg1)->SetMinimumSpeedForFlick(arg2);
81502     } catch (std::out_of_range& e) {
81503       {
81504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81505       };
81506     } catch (std::exception& e) {
81507       {
81508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81509       };
81510     } catch (Dali::DaliException e) {
81511       {
81512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81513       };
81514     } catch (...) {
81515       {
81516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81517       };
81518     }
81519   }
81520
81521 }
81522
81523
81524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81525   float jresult ;
81526   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81527   float result;
81528
81529   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81530   {
81531     try {
81532       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81533     } catch (std::out_of_range& e) {
81534       {
81535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81536       };
81537     } catch (std::exception& e) {
81538       {
81539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81540       };
81541     } catch (Dali::DaliException e) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81544       };
81545     } catch (...) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81548       };
81549     }
81550   }
81551
81552   jresult = result;
81553   return jresult;
81554 }
81555
81556
81557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81558   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81559   float arg2 ;
81560
81561   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81562   arg2 = (float)jarg2;
81563   {
81564     try {
81565       (arg1)->SetMaxFlickSpeed(arg2);
81566     } catch (std::out_of_range& e) {
81567       {
81568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81569       };
81570     } catch (std::exception& e) {
81571       {
81572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81573       };
81574     } catch (Dali::DaliException e) {
81575       {
81576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81577       };
81578     } catch (...) {
81579       {
81580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81581       };
81582     }
81583   }
81584
81585 }
81586
81587
81588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81589   void * jresult ;
81590   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81591   Dali::Vector2 result;
81592
81593   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81594   {
81595     try {
81596       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81597     } catch (std::out_of_range& e) {
81598       {
81599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81600       };
81601     } catch (std::exception& e) {
81602       {
81603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81604       };
81605     } catch (Dali::DaliException e) {
81606       {
81607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81608       };
81609     } catch (...) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81612       };
81613     }
81614   }
81615
81616   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81617   return jresult;
81618 }
81619
81620
81621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81622   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81623   Dali::Vector2 arg2 ;
81624   Dali::Vector2 *argp2 ;
81625
81626   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81627   argp2 = (Dali::Vector2 *)jarg2;
81628   if (!argp2) {
81629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81630     return ;
81631   }
81632   arg2 = *argp2;
81633   {
81634     try {
81635       (arg1)->SetWheelScrollDistanceStep(arg2);
81636     } catch (std::out_of_range& e) {
81637       {
81638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81639       };
81640     } catch (std::exception& e) {
81641       {
81642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81643       };
81644     } catch (Dali::DaliException e) {
81645       {
81646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81647       };
81648     } catch (...) {
81649       {
81650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81651       };
81652     }
81653   }
81654
81655 }
81656
81657
81658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81659   void * jresult ;
81660   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81661   Dali::Vector2 result;
81662
81663   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81664   {
81665     try {
81666       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81667     } catch (std::out_of_range& e) {
81668       {
81669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81670       };
81671     } catch (std::exception& e) {
81672       {
81673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81674       };
81675     } catch (Dali::DaliException e) {
81676       {
81677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81678       };
81679     } catch (...) {
81680       {
81681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81682       };
81683     }
81684   }
81685
81686   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81687   return jresult;
81688 }
81689
81690
81691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81692   unsigned int jresult ;
81693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81694   unsigned int result;
81695
81696   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81697   {
81698     try {
81699       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81700     } catch (std::out_of_range& e) {
81701       {
81702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81703       };
81704     } catch (std::exception& e) {
81705       {
81706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81707       };
81708     } catch (Dali::DaliException e) {
81709       {
81710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81711       };
81712     } catch (...) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81715       };
81716     }
81717   }
81718
81719   jresult = result;
81720   return jresult;
81721 }
81722
81723
81724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81725   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81726   Dali::Vector2 *arg2 = 0 ;
81727
81728   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81729   arg2 = (Dali::Vector2 *)jarg2;
81730   if (!arg2) {
81731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81732     return ;
81733   }
81734   {
81735     try {
81736       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81737     } catch (std::out_of_range& e) {
81738       {
81739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81740       };
81741     } catch (std::exception& e) {
81742       {
81743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81744       };
81745     } catch (Dali::DaliException e) {
81746       {
81747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81748       };
81749     } catch (...) {
81750       {
81751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81752       };
81753     }
81754   }
81755
81756 }
81757
81758
81759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81760   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81761   Dali::Vector2 *arg2 = 0 ;
81762   float arg3 ;
81763
81764   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81765   arg2 = (Dali::Vector2 *)jarg2;
81766   if (!arg2) {
81767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81768     return ;
81769   }
81770   arg3 = (float)jarg3;
81771   {
81772     try {
81773       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81774     } catch (std::out_of_range& e) {
81775       {
81776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81777       };
81778     } catch (std::exception& e) {
81779       {
81780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81781       };
81782     } catch (Dali::DaliException e) {
81783       {
81784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81785       };
81786     } catch (...) {
81787       {
81788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81789       };
81790     }
81791   }
81792
81793 }
81794
81795
81796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81798   Dali::Vector2 *arg2 = 0 ;
81799   float arg3 ;
81800   Dali::AlphaFunction arg4 ;
81801   Dali::AlphaFunction *argp4 ;
81802
81803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81804   arg2 = (Dali::Vector2 *)jarg2;
81805   if (!arg2) {
81806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81807     return ;
81808   }
81809   arg3 = (float)jarg3;
81810   argp4 = (Dali::AlphaFunction *)jarg4;
81811   if (!argp4) {
81812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81813     return ;
81814   }
81815   arg4 = *argp4;
81816   {
81817     try {
81818       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81819     } catch (std::out_of_range& e) {
81820       {
81821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81822       };
81823     } catch (std::exception& e) {
81824       {
81825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81826       };
81827     } catch (Dali::DaliException e) {
81828       {
81829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81830       };
81831     } catch (...) {
81832       {
81833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81834       };
81835     }
81836   }
81837
81838 }
81839
81840
81841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81843   Dali::Vector2 *arg2 = 0 ;
81844   float arg3 ;
81845   Dali::Toolkit::DirectionBias arg4 ;
81846   Dali::Toolkit::DirectionBias arg5 ;
81847
81848   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81849   arg2 = (Dali::Vector2 *)jarg2;
81850   if (!arg2) {
81851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81852     return ;
81853   }
81854   arg3 = (float)jarg3;
81855   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81856   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81857   {
81858     try {
81859       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81860     } catch (std::out_of_range& e) {
81861       {
81862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81863       };
81864     } catch (std::exception& e) {
81865       {
81866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81867       };
81868     } catch (Dali::DaliException e) {
81869       {
81870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81871       };
81872     } catch (...) {
81873       {
81874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81875       };
81876     }
81877   }
81878
81879 }
81880
81881
81882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81884   Dali::Vector2 *arg2 = 0 ;
81885   float arg3 ;
81886   Dali::AlphaFunction arg4 ;
81887   Dali::Toolkit::DirectionBias arg5 ;
81888   Dali::Toolkit::DirectionBias arg6 ;
81889   Dali::AlphaFunction *argp4 ;
81890
81891   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81892   arg2 = (Dali::Vector2 *)jarg2;
81893   if (!arg2) {
81894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81895     return ;
81896   }
81897   arg3 = (float)jarg3;
81898   argp4 = (Dali::AlphaFunction *)jarg4;
81899   if (!argp4) {
81900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81901     return ;
81902   }
81903   arg4 = *argp4;
81904   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81905   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81906   {
81907     try {
81908       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81909     } catch (std::out_of_range& e) {
81910       {
81911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81912       };
81913     } catch (std::exception& e) {
81914       {
81915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81916       };
81917     } catch (Dali::DaliException e) {
81918       {
81919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81920       };
81921     } catch (...) {
81922       {
81923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81924       };
81925     }
81926   }
81927
81928 }
81929
81930
81931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81933   unsigned int arg2 ;
81934
81935   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81936   arg2 = (unsigned int)jarg2;
81937   {
81938     try {
81939       (arg1)->ScrollTo(arg2);
81940     } catch (std::out_of_range& e) {
81941       {
81942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81943       };
81944     } catch (std::exception& e) {
81945       {
81946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81947       };
81948     } catch (Dali::DaliException e) {
81949       {
81950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81951       };
81952     } catch (...) {
81953       {
81954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81955       };
81956     }
81957   }
81958
81959 }
81960
81961
81962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81964   unsigned int arg2 ;
81965   float arg3 ;
81966
81967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81968   arg2 = (unsigned int)jarg2;
81969   arg3 = (float)jarg3;
81970   {
81971     try {
81972       (arg1)->ScrollTo(arg2,arg3);
81973     } catch (std::out_of_range& e) {
81974       {
81975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81976       };
81977     } catch (std::exception& e) {
81978       {
81979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81980       };
81981     } catch (Dali::DaliException e) {
81982       {
81983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81984       };
81985     } catch (...) {
81986       {
81987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81988       };
81989     }
81990   }
81991
81992 }
81993
81994
81995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81997   unsigned int arg2 ;
81998   float arg3 ;
81999   Dali::Toolkit::DirectionBias arg4 ;
82000
82001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82002   arg2 = (unsigned int)jarg2;
82003   arg3 = (float)jarg3;
82004   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82005   {
82006     try {
82007       (arg1)->ScrollTo(arg2,arg3,arg4);
82008     } catch (std::out_of_range& e) {
82009       {
82010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82011       };
82012     } catch (std::exception& e) {
82013       {
82014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82015       };
82016     } catch (Dali::DaliException e) {
82017       {
82018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82019       };
82020     } catch (...) {
82021       {
82022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82023       };
82024     }
82025   }
82026
82027 }
82028
82029
82030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82032   Dali::Actor *arg2 = 0 ;
82033
82034   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82035   arg2 = (Dali::Actor *)jarg2;
82036   if (!arg2) {
82037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82038     return ;
82039   }
82040   {
82041     try {
82042       (arg1)->ScrollTo(*arg2);
82043     } catch (std::out_of_range& e) {
82044       {
82045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82046       };
82047     } catch (std::exception& e) {
82048       {
82049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82050       };
82051     } catch (Dali::DaliException e) {
82052       {
82053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82054       };
82055     } catch (...) {
82056       {
82057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82058       };
82059     }
82060   }
82061
82062 }
82063
82064
82065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82066   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82067   Dali::Actor *arg2 = 0 ;
82068   float arg3 ;
82069
82070   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82071   arg2 = (Dali::Actor *)jarg2;
82072   if (!arg2) {
82073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82074     return ;
82075   }
82076   arg3 = (float)jarg3;
82077   {
82078     try {
82079       (arg1)->ScrollTo(*arg2,arg3);
82080     } catch (std::out_of_range& e) {
82081       {
82082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82083       };
82084     } catch (std::exception& e) {
82085       {
82086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82087       };
82088     } catch (Dali::DaliException e) {
82089       {
82090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82091       };
82092     } catch (...) {
82093       {
82094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82095       };
82096     }
82097   }
82098
82099 }
82100
82101
82102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82103   unsigned int jresult ;
82104   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82105   bool result;
82106
82107   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82108   {
82109     try {
82110       result = (bool)(arg1)->ScrollToSnapPoint();
82111     } catch (std::out_of_range& e) {
82112       {
82113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82114       };
82115     } catch (std::exception& e) {
82116       {
82117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82118       };
82119     } catch (Dali::DaliException e) {
82120       {
82121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82122       };
82123     } catch (...) {
82124       {
82125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82126       };
82127     }
82128   }
82129
82130   jresult = result;
82131   return jresult;
82132 }
82133
82134
82135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82136   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82137   Dali::Constraint arg2 ;
82138   Dali::Constraint *argp2 ;
82139
82140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82141   argp2 = (Dali::Constraint *)jarg2;
82142   if (!argp2) {
82143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82144     return ;
82145   }
82146   arg2 = *argp2;
82147   {
82148     try {
82149       (arg1)->ApplyConstraintToChildren(arg2);
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82165       };
82166     }
82167   }
82168
82169 }
82170
82171
82172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82173   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82174
82175   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82176   {
82177     try {
82178       (arg1)->RemoveConstraintsFromChildren();
82179     } catch (std::out_of_range& e) {
82180       {
82181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82182       };
82183     } catch (std::exception& e) {
82184       {
82185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82186       };
82187     } catch (Dali::DaliException e) {
82188       {
82189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82190       };
82191     } catch (...) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82194       };
82195     }
82196   }
82197
82198 }
82199
82200
82201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82203   Dali::Toolkit::ScrollViewEffect arg2 ;
82204   Dali::Toolkit::ScrollViewEffect *argp2 ;
82205
82206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82207   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82208   if (!argp2) {
82209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82210     return ;
82211   }
82212   arg2 = *argp2;
82213   {
82214     try {
82215       (arg1)->ApplyEffect(arg2);
82216     } catch (std::out_of_range& e) {
82217       {
82218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82219       };
82220     } catch (std::exception& e) {
82221       {
82222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82223       };
82224     } catch (Dali::DaliException e) {
82225       {
82226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82227       };
82228     } catch (...) {
82229       {
82230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82231       };
82232     }
82233   }
82234
82235 }
82236
82237
82238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82239   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82240   Dali::Toolkit::ScrollViewEffect arg2 ;
82241   Dali::Toolkit::ScrollViewEffect *argp2 ;
82242
82243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82244   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82245   if (!argp2) {
82246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82247     return ;
82248   }
82249   arg2 = *argp2;
82250   {
82251     try {
82252       (arg1)->RemoveEffect(arg2);
82253     } catch (std::out_of_range& e) {
82254       {
82255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82256       };
82257     } catch (std::exception& e) {
82258       {
82259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82260       };
82261     } catch (Dali::DaliException e) {
82262       {
82263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82264       };
82265     } catch (...) {
82266       {
82267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82268       };
82269     }
82270   }
82271
82272 }
82273
82274
82275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82276   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82277
82278   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82279   {
82280     try {
82281       (arg1)->RemoveAllEffects();
82282     } catch (std::out_of_range& e) {
82283       {
82284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82285       };
82286     } catch (std::exception& e) {
82287       {
82288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82289       };
82290     } catch (Dali::DaliException e) {
82291       {
82292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82293       };
82294     } catch (...) {
82295       {
82296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82297       };
82298     }
82299   }
82300
82301 }
82302
82303
82304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82305   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82306   Dali::Actor arg2 ;
82307   Dali::Actor *argp2 ;
82308
82309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82310   argp2 = (Dali::Actor *)jarg2;
82311   if (!argp2) {
82312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82313     return ;
82314   }
82315   arg2 = *argp2;
82316   {
82317     try {
82318       (arg1)->BindActor(arg2);
82319     } catch (std::out_of_range& e) {
82320       {
82321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82322       };
82323     } catch (std::exception& e) {
82324       {
82325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82326       };
82327     } catch (Dali::DaliException e) {
82328       {
82329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82330       };
82331     } catch (...) {
82332       {
82333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82334       };
82335     }
82336   }
82337
82338 }
82339
82340
82341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82342   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82343   Dali::Actor arg2 ;
82344   Dali::Actor *argp2 ;
82345
82346   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82347   argp2 = (Dali::Actor *)jarg2;
82348   if (!argp2) {
82349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82350     return ;
82351   }
82352   arg2 = *argp2;
82353   {
82354     try {
82355       (arg1)->UnbindActor(arg2);
82356     } catch (std::out_of_range& e) {
82357       {
82358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82359       };
82360     } catch (std::exception& e) {
82361       {
82362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82363       };
82364     } catch (Dali::DaliException e) {
82365       {
82366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82367       };
82368     } catch (...) {
82369       {
82370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82371       };
82372     }
82373   }
82374
82375 }
82376
82377
82378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82380   Dali::Radian arg2 ;
82381   Dali::Radian arg3 ;
82382   Dali::Radian *argp2 ;
82383   Dali::Radian *argp3 ;
82384
82385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82386   argp2 = (Dali::Radian *)jarg2;
82387   if (!argp2) {
82388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82389     return ;
82390   }
82391   arg2 = *argp2;
82392   argp3 = (Dali::Radian *)jarg3;
82393   if (!argp3) {
82394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82395     return ;
82396   }
82397   arg3 = *argp3;
82398   {
82399     try {
82400       (arg1)->SetScrollingDirection(arg2,arg3);
82401     } catch (std::out_of_range& e) {
82402       {
82403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82404       };
82405     } catch (std::exception& e) {
82406       {
82407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82408       };
82409     } catch (Dali::DaliException e) {
82410       {
82411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82412       };
82413     } catch (...) {
82414       {
82415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82416       };
82417     }
82418   }
82419
82420 }
82421
82422
82423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82424   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82425   Dali::Radian arg2 ;
82426   Dali::Radian *argp2 ;
82427
82428   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82429   argp2 = (Dali::Radian *)jarg2;
82430   if (!argp2) {
82431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82432     return ;
82433   }
82434   arg2 = *argp2;
82435   {
82436     try {
82437       (arg1)->SetScrollingDirection(arg2);
82438     } catch (std::out_of_range& e) {
82439       {
82440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82441       };
82442     } catch (std::exception& e) {
82443       {
82444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82445       };
82446     } catch (Dali::DaliException e) {
82447       {
82448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82449       };
82450     } catch (...) {
82451       {
82452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82453       };
82454     }
82455   }
82456
82457 }
82458
82459
82460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82462   Dali::Radian arg2 ;
82463   Dali::Radian *argp2 ;
82464
82465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82466   argp2 = (Dali::Radian *)jarg2;
82467   if (!argp2) {
82468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82469     return ;
82470   }
82471   arg2 = *argp2;
82472   {
82473     try {
82474       (arg1)->RemoveScrollingDirection(arg2);
82475     } catch (std::out_of_range& e) {
82476       {
82477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82478       };
82479     } catch (std::exception& e) {
82480       {
82481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82482       };
82483     } catch (Dali::DaliException e) {
82484       {
82485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82486       };
82487     } catch (...) {
82488       {
82489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82490       };
82491     }
82492   }
82493
82494 }
82495
82496
82497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82498   void * jresult ;
82499   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82500   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82501
82502   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82503   {
82504     try {
82505       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82506     } catch (std::out_of_range& e) {
82507       {
82508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82509       };
82510     } catch (std::exception& e) {
82511       {
82512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82513       };
82514     } catch (Dali::DaliException e) {
82515       {
82516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82517       };
82518     } catch (...) {
82519       {
82520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82521       };
82522     }
82523   }
82524
82525   jresult = (void *)result;
82526   return jresult;
82527 }
82528
82529
82530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82531   int jresult ;
82532   int result;
82533
82534   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82535   jresult = (int)result;
82536   return jresult;
82537 }
82538
82539
82540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82541   int jresult ;
82542   int result;
82543
82544   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82545   jresult = (int)result;
82546   return jresult;
82547 }
82548
82549
82550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82551   int jresult ;
82552   int result;
82553
82554   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82555   jresult = (int)result;
82556   return jresult;
82557 }
82558
82559
82560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82561   int jresult ;
82562   int result;
82563
82564   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82565   jresult = (int)result;
82566   return jresult;
82567 }
82568
82569
82570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82571   int jresult ;
82572   int result;
82573
82574   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82575   jresult = (int)result;
82576   return jresult;
82577 }
82578
82579
82580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82581   void * jresult ;
82582   Dali::Toolkit::TableView::Property *result = 0 ;
82583
82584   {
82585     try {
82586       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82587     } catch (std::out_of_range& e) {
82588       {
82589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82590       };
82591     } catch (std::exception& e) {
82592       {
82593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82594       };
82595     } catch (Dali::DaliException e) {
82596       {
82597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82598       };
82599     } catch (...) {
82600       {
82601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82602       };
82603     }
82604   }
82605
82606   jresult = (void *)result;
82607   return jresult;
82608 }
82609
82610
82611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82612   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82613
82614   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82615   {
82616     try {
82617       delete arg1;
82618     } catch (std::out_of_range& e) {
82619       {
82620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82621       };
82622     } catch (std::exception& e) {
82623       {
82624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82625       };
82626     } catch (Dali::DaliException e) {
82627       {
82628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82629       };
82630     } catch (...) {
82631       {
82632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82633       };
82634     }
82635   }
82636
82637 }
82638
82639
82640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82641   int jresult ;
82642   int result;
82643
82644   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82645   jresult = (int)result;
82646   return jresult;
82647 }
82648
82649
82650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82651   int jresult ;
82652   int result;
82653
82654   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82655   jresult = (int)result;
82656   return jresult;
82657 }
82658
82659
82660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82661   int jresult ;
82662   int result;
82663
82664   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82665   jresult = (int)result;
82666   return jresult;
82667 }
82668
82669
82670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82671   int jresult ;
82672   int result;
82673
82674   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82675   jresult = (int)result;
82676   return jresult;
82677 }
82678
82679
82680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82681   int jresult ;
82682   int result;
82683
82684   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82685   jresult = (int)result;
82686   return jresult;
82687 }
82688
82689
82690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82691   void * jresult ;
82692   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82693
82694   {
82695     try {
82696       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82697     } catch (std::out_of_range& e) {
82698       {
82699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82700       };
82701     } catch (std::exception& e) {
82702       {
82703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82704       };
82705     } catch (Dali::DaliException e) {
82706       {
82707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82708       };
82709     } catch (...) {
82710       {
82711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82712       };
82713     }
82714   }
82715
82716   jresult = (void *)result;
82717   return jresult;
82718 }
82719
82720
82721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82722   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82723
82724   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82725   {
82726     try {
82727       delete arg1;
82728     } catch (std::out_of_range& e) {
82729       {
82730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82731       };
82732     } catch (std::exception& e) {
82733       {
82734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82735       };
82736     } catch (Dali::DaliException e) {
82737       {
82738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82739       };
82740     } catch (...) {
82741       {
82742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82743       };
82744     }
82745   }
82746
82747 }
82748
82749
82750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82751   void * jresult ;
82752   unsigned int arg1 ;
82753   unsigned int arg2 ;
82754   unsigned int arg3 ;
82755   unsigned int arg4 ;
82756   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82757
82758   arg1 = (unsigned int)jarg1;
82759   arg2 = (unsigned int)jarg2;
82760   arg3 = (unsigned int)jarg3;
82761   arg4 = (unsigned int)jarg4;
82762   {
82763     try {
82764       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82765     } catch (std::out_of_range& e) {
82766       {
82767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82768       };
82769     } catch (std::exception& e) {
82770       {
82771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82772       };
82773     } catch (Dali::DaliException e) {
82774       {
82775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82776       };
82777     } catch (...) {
82778       {
82779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82780       };
82781     }
82782   }
82783
82784   jresult = (void *)result;
82785   return jresult;
82786 }
82787
82788
82789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82790   void * jresult ;
82791   unsigned int arg1 ;
82792   unsigned int arg2 ;
82793   unsigned int arg3 ;
82794   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82795
82796   arg1 = (unsigned int)jarg1;
82797   arg2 = (unsigned int)jarg2;
82798   arg3 = (unsigned int)jarg3;
82799   {
82800     try {
82801       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82802     } catch (std::out_of_range& e) {
82803       {
82804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82805       };
82806     } catch (std::exception& e) {
82807       {
82808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82809       };
82810     } catch (Dali::DaliException e) {
82811       {
82812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82813       };
82814     } catch (...) {
82815       {
82816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82817       };
82818     }
82819   }
82820
82821   jresult = (void *)result;
82822   return jresult;
82823 }
82824
82825
82826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82827   void * jresult ;
82828   unsigned int arg1 ;
82829   unsigned int arg2 ;
82830   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82831
82832   arg1 = (unsigned int)jarg1;
82833   arg2 = (unsigned int)jarg2;
82834   {
82835     try {
82836       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82837     } catch (std::out_of_range& e) {
82838       {
82839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82840       };
82841     } catch (std::exception& e) {
82842       {
82843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82844       };
82845     } catch (Dali::DaliException e) {
82846       {
82847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82848       };
82849     } catch (...) {
82850       {
82851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82852       };
82853     }
82854   }
82855
82856   jresult = (void *)result;
82857   return jresult;
82858 }
82859
82860
82861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82862   void * jresult ;
82863   unsigned int arg1 ;
82864   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82865
82866   arg1 = (unsigned int)jarg1;
82867   {
82868     try {
82869       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82870     } catch (std::out_of_range& e) {
82871       {
82872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82873       };
82874     } catch (std::exception& e) {
82875       {
82876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82877       };
82878     } catch (Dali::DaliException e) {
82879       {
82880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82881       };
82882     } catch (...) {
82883       {
82884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82885       };
82886     }
82887   }
82888
82889   jresult = (void *)result;
82890   return jresult;
82891 }
82892
82893
82894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82895   void * jresult ;
82896   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82897
82898   {
82899     try {
82900       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82901     } catch (std::out_of_range& e) {
82902       {
82903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82904       };
82905     } catch (std::exception& e) {
82906       {
82907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82908       };
82909     } catch (Dali::DaliException e) {
82910       {
82911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82912       };
82913     } catch (...) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82916       };
82917     }
82918   }
82919
82920   jresult = (void *)result;
82921   return jresult;
82922 }
82923
82924
82925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82926   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82927   unsigned int arg2 ;
82928
82929   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82930   arg2 = (unsigned int)jarg2;
82931   if (arg1) (arg1)->rowIndex = arg2;
82932 }
82933
82934
82935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82936   unsigned int jresult ;
82937   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82938   unsigned int result;
82939
82940   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82941   result = (unsigned int) ((arg1)->rowIndex);
82942   jresult = result;
82943   return jresult;
82944 }
82945
82946
82947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82948   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82949   unsigned int arg2 ;
82950
82951   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82952   arg2 = (unsigned int)jarg2;
82953   if (arg1) (arg1)->columnIndex = arg2;
82954 }
82955
82956
82957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82958   unsigned int jresult ;
82959   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82960   unsigned int result;
82961
82962   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82963   result = (unsigned int) ((arg1)->columnIndex);
82964   jresult = result;
82965   return jresult;
82966 }
82967
82968
82969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82970   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82971   unsigned int arg2 ;
82972
82973   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82974   arg2 = (unsigned int)jarg2;
82975   if (arg1) (arg1)->rowSpan = arg2;
82976 }
82977
82978
82979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82980   unsigned int jresult ;
82981   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82982   unsigned int result;
82983
82984   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82985   result = (unsigned int) ((arg1)->rowSpan);
82986   jresult = result;
82987   return jresult;
82988 }
82989
82990
82991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82992   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82993   unsigned int arg2 ;
82994
82995   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82996   arg2 = (unsigned int)jarg2;
82997   if (arg1) (arg1)->columnSpan = arg2;
82998 }
82999
83000
83001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83002   unsigned int jresult ;
83003   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83004   unsigned int result;
83005
83006   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83007   result = (unsigned int) ((arg1)->columnSpan);
83008   jresult = result;
83009   return jresult;
83010 }
83011
83012
83013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83014   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83015
83016   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83017   {
83018     try {
83019       delete arg1;
83020     } catch (std::out_of_range& e) {
83021       {
83022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83023       };
83024     } catch (std::exception& e) {
83025       {
83026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83027       };
83028     } catch (Dali::DaliException e) {
83029       {
83030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83031       };
83032     } catch (...) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83035       };
83036     }
83037   }
83038
83039 }
83040
83041
83042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83043   void * jresult ;
83044   Dali::Toolkit::TableView *result = 0 ;
83045
83046   {
83047     try {
83048       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83049     } catch (std::out_of_range& e) {
83050       {
83051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83052       };
83053     } catch (std::exception& e) {
83054       {
83055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83056       };
83057     } catch (Dali::DaliException e) {
83058       {
83059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83060       };
83061     } catch (...) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83064       };
83065     }
83066   }
83067
83068   jresult = (void *)result;
83069   return jresult;
83070 }
83071
83072
83073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83074   void * jresult ;
83075   Dali::Toolkit::TableView *arg1 = 0 ;
83076   Dali::Toolkit::TableView *result = 0 ;
83077
83078   arg1 = (Dali::Toolkit::TableView *)jarg1;
83079   if (!arg1) {
83080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83081     return 0;
83082   }
83083   {
83084     try {
83085       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83086     } catch (std::out_of_range& e) {
83087       {
83088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (std::exception& e) {
83091       {
83092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83093       };
83094     } catch (Dali::DaliException e) {
83095       {
83096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83097       };
83098     } catch (...) {
83099       {
83100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83101       };
83102     }
83103   }
83104
83105   jresult = (void *)result;
83106   return jresult;
83107 }
83108
83109
83110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83111   void * jresult ;
83112   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83113   Dali::Toolkit::TableView *arg2 = 0 ;
83114   Dali::Toolkit::TableView *result = 0 ;
83115
83116   arg1 = (Dali::Toolkit::TableView *)jarg1;
83117   arg2 = (Dali::Toolkit::TableView *)jarg2;
83118   if (!arg2) {
83119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83120     return 0;
83121   }
83122   {
83123     try {
83124       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83125     } catch (std::out_of_range& e) {
83126       {
83127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83128       };
83129     } catch (std::exception& e) {
83130       {
83131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (Dali::DaliException e) {
83134       {
83135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83136       };
83137     } catch (...) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83140       };
83141     }
83142   }
83143
83144   jresult = (void *)result;
83145   return jresult;
83146 }
83147
83148
83149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83150   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83151
83152   arg1 = (Dali::Toolkit::TableView *)jarg1;
83153   {
83154     try {
83155       delete arg1;
83156     } catch (std::out_of_range& e) {
83157       {
83158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83159       };
83160     } catch (std::exception& e) {
83161       {
83162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83163       };
83164     } catch (Dali::DaliException e) {
83165       {
83166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83167       };
83168     } catch (...) {
83169       {
83170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83171       };
83172     }
83173   }
83174
83175 }
83176
83177
83178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83179   void * jresult ;
83180   unsigned int arg1 ;
83181   unsigned int arg2 ;
83182   Dali::Toolkit::TableView result;
83183
83184   arg1 = (unsigned int)jarg1;
83185   arg2 = (unsigned int)jarg2;
83186   {
83187     try {
83188       result = Dali::Toolkit::TableView::New(arg1,arg2);
83189     } catch (std::out_of_range& e) {
83190       {
83191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83192       };
83193     } catch (std::exception& e) {
83194       {
83195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83196       };
83197     } catch (Dali::DaliException e) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83200       };
83201     } catch (...) {
83202       {
83203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83204       };
83205     }
83206   }
83207
83208   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83209   return jresult;
83210 }
83211
83212
83213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83214   void * jresult ;
83215   Dali::BaseHandle arg1 ;
83216   Dali::BaseHandle *argp1 ;
83217   Dali::Toolkit::TableView result;
83218
83219   argp1 = (Dali::BaseHandle *)jarg1;
83220   if (!argp1) {
83221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83222     return 0;
83223   }
83224   arg1 = *argp1;
83225   {
83226     try {
83227       result = Dali::Toolkit::TableView::DownCast(arg1);
83228     } catch (std::out_of_range& e) {
83229       {
83230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83231       };
83232     } catch (std::exception& e) {
83233       {
83234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83235       };
83236     } catch (Dali::DaliException e) {
83237       {
83238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83239       };
83240     } catch (...) {
83241       {
83242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83243       };
83244     }
83245   }
83246
83247   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83248   return jresult;
83249 }
83250
83251
83252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83253   unsigned int jresult ;
83254   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83255   Dali::Actor arg2 ;
83256   Dali::Toolkit::TableView::CellPosition arg3 ;
83257   Dali::Actor *argp2 ;
83258   Dali::Toolkit::TableView::CellPosition *argp3 ;
83259   bool result;
83260
83261   arg1 = (Dali::Toolkit::TableView *)jarg1;
83262   argp2 = (Dali::Actor *)jarg2;
83263   if (!argp2) {
83264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83265     return 0;
83266   }
83267   arg2 = *argp2;
83268   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83269   if (!argp3) {
83270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83271     return 0;
83272   }
83273   arg3 = *argp3;
83274   {
83275     try {
83276       result = (bool)(arg1)->AddChild(arg2,arg3);
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83284       };
83285     } catch (Dali::DaliException e) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83288       };
83289     } catch (...) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83292       };
83293     }
83294   }
83295
83296   jresult = result;
83297   return jresult;
83298 }
83299
83300
83301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83302   void * jresult ;
83303   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83304   Dali::Toolkit::TableView::CellPosition arg2 ;
83305   Dali::Toolkit::TableView::CellPosition *argp2 ;
83306   Dali::Actor result;
83307
83308   arg1 = (Dali::Toolkit::TableView *)jarg1;
83309   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83310   if (!argp2) {
83311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83312     return 0;
83313   }
83314   arg2 = *argp2;
83315   {
83316     try {
83317       result = (arg1)->GetChildAt(arg2);
83318     } catch (std::out_of_range& e) {
83319       {
83320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83321       };
83322     } catch (std::exception& e) {
83323       {
83324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83325       };
83326     } catch (Dali::DaliException e) {
83327       {
83328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83329       };
83330     } catch (...) {
83331       {
83332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83333       };
83334     }
83335   }
83336
83337   jresult = new Dali::Actor((const Dali::Actor &)result);
83338   return jresult;
83339 }
83340
83341
83342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83343   void * jresult ;
83344   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83345   Dali::Toolkit::TableView::CellPosition arg2 ;
83346   Dali::Toolkit::TableView::CellPosition *argp2 ;
83347   Dali::Actor result;
83348
83349   arg1 = (Dali::Toolkit::TableView *)jarg1;
83350   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83351   if (!argp2) {
83352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83353     return 0;
83354   }
83355   arg2 = *argp2;
83356   {
83357     try {
83358       result = (arg1)->RemoveChildAt(arg2);
83359     } catch (std::out_of_range& e) {
83360       {
83361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83362       };
83363     } catch (std::exception& e) {
83364       {
83365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83366       };
83367     } catch (Dali::DaliException e) {
83368       {
83369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83370       };
83371     } catch (...) {
83372       {
83373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83374       };
83375     }
83376   }
83377
83378   jresult = new Dali::Actor((const Dali::Actor &)result);
83379   return jresult;
83380 }
83381
83382
83383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83384   unsigned int jresult ;
83385   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83386   Dali::Actor arg2 ;
83387   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83388   Dali::Actor *argp2 ;
83389   bool result;
83390
83391   arg1 = (Dali::Toolkit::TableView *)jarg1;
83392   argp2 = (Dali::Actor *)jarg2;
83393   if (!argp2) {
83394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83395     return 0;
83396   }
83397   arg2 = *argp2;
83398   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83399   if (!arg3) {
83400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83401     return 0;
83402   }
83403   {
83404     try {
83405       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83406     } catch (std::out_of_range& e) {
83407       {
83408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83409       };
83410     } catch (std::exception& e) {
83411       {
83412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83413       };
83414     } catch (Dali::DaliException e) {
83415       {
83416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83417       };
83418     } catch (...) {
83419       {
83420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83421       };
83422     }
83423   }
83424
83425   jresult = result;
83426   return jresult;
83427 }
83428
83429
83430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83431   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83432   unsigned int arg2 ;
83433
83434   arg1 = (Dali::Toolkit::TableView *)jarg1;
83435   arg2 = (unsigned int)jarg2;
83436   {
83437     try {
83438       (arg1)->InsertRow(arg2);
83439     } catch (std::out_of_range& e) {
83440       {
83441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83442       };
83443     } catch (std::exception& e) {
83444       {
83445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83446       };
83447     } catch (Dali::DaliException e) {
83448       {
83449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83450       };
83451     } catch (...) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83454       };
83455     }
83456   }
83457
83458 }
83459
83460
83461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83462   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83463   unsigned int arg2 ;
83464
83465   arg1 = (Dali::Toolkit::TableView *)jarg1;
83466   arg2 = (unsigned int)jarg2;
83467   {
83468     try {
83469       (arg1)->DeleteRow(arg2);
83470     } catch (std::out_of_range& e) {
83471       {
83472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83473       };
83474     } catch (std::exception& e) {
83475       {
83476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83477       };
83478     } catch (Dali::DaliException e) {
83479       {
83480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83481       };
83482     } catch (...) {
83483       {
83484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83485       };
83486     }
83487   }
83488
83489 }
83490
83491
83492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83493   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83494   unsigned int arg2 ;
83495   std::vector< Dali::Actor > *arg3 = 0 ;
83496
83497   arg1 = (Dali::Toolkit::TableView *)jarg1;
83498   arg2 = (unsigned int)jarg2;
83499   arg3 = (std::vector< Dali::Actor > *)jarg3;
83500   if (!arg3) {
83501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83502     return ;
83503   }
83504   {
83505     try {
83506       (arg1)->DeleteRow(arg2,*arg3);
83507     } catch (std::out_of_range& e) {
83508       {
83509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83510       };
83511     } catch (std::exception& e) {
83512       {
83513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83514       };
83515     } catch (Dali::DaliException e) {
83516       {
83517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83518       };
83519     } catch (...) {
83520       {
83521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83522       };
83523     }
83524   }
83525
83526 }
83527
83528
83529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83530   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83531   unsigned int arg2 ;
83532
83533   arg1 = (Dali::Toolkit::TableView *)jarg1;
83534   arg2 = (unsigned int)jarg2;
83535   {
83536     try {
83537       (arg1)->InsertColumn(arg2);
83538     } catch (std::out_of_range& e) {
83539       {
83540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83541       };
83542     } catch (std::exception& e) {
83543       {
83544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83545       };
83546     } catch (Dali::DaliException e) {
83547       {
83548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83549       };
83550     } catch (...) {
83551       {
83552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83553       };
83554     }
83555   }
83556
83557 }
83558
83559
83560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83561   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83562   unsigned int arg2 ;
83563
83564   arg1 = (Dali::Toolkit::TableView *)jarg1;
83565   arg2 = (unsigned int)jarg2;
83566   {
83567     try {
83568       (arg1)->DeleteColumn(arg2);
83569     } catch (std::out_of_range& e) {
83570       {
83571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83572       };
83573     } catch (std::exception& e) {
83574       {
83575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83576       };
83577     } catch (Dali::DaliException e) {
83578       {
83579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83580       };
83581     } catch (...) {
83582       {
83583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83584       };
83585     }
83586   }
83587
83588 }
83589
83590
83591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83592   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83593   unsigned int arg2 ;
83594   std::vector< Dali::Actor > *arg3 = 0 ;
83595
83596   arg1 = (Dali::Toolkit::TableView *)jarg1;
83597   arg2 = (unsigned int)jarg2;
83598   arg3 = (std::vector< Dali::Actor > *)jarg3;
83599   if (!arg3) {
83600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83601     return ;
83602   }
83603   {
83604     try {
83605       (arg1)->DeleteColumn(arg2,*arg3);
83606     } catch (std::out_of_range& e) {
83607       {
83608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83609       };
83610     } catch (std::exception& e) {
83611       {
83612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83613       };
83614     } catch (Dali::DaliException e) {
83615       {
83616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83617       };
83618     } catch (...) {
83619       {
83620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83621       };
83622     }
83623   }
83624
83625 }
83626
83627
83628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83629   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83630   unsigned int arg2 ;
83631   unsigned int arg3 ;
83632
83633   arg1 = (Dali::Toolkit::TableView *)jarg1;
83634   arg2 = (unsigned int)jarg2;
83635   arg3 = (unsigned int)jarg3;
83636   {
83637     try {
83638       (arg1)->Resize(arg2,arg3);
83639     } catch (std::out_of_range& e) {
83640       {
83641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83642       };
83643     } catch (std::exception& e) {
83644       {
83645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83646       };
83647     } catch (Dali::DaliException e) {
83648       {
83649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83650       };
83651     } catch (...) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83654       };
83655     }
83656   }
83657
83658 }
83659
83660
83661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83662   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83663   unsigned int arg2 ;
83664   unsigned int arg3 ;
83665   std::vector< Dali::Actor > *arg4 = 0 ;
83666
83667   arg1 = (Dali::Toolkit::TableView *)jarg1;
83668   arg2 = (unsigned int)jarg2;
83669   arg3 = (unsigned int)jarg3;
83670   arg4 = (std::vector< Dali::Actor > *)jarg4;
83671   if (!arg4) {
83672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83673     return ;
83674   }
83675   {
83676     try {
83677       (arg1)->Resize(arg2,arg3,*arg4);
83678     } catch (std::out_of_range& e) {
83679       {
83680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83681       };
83682     } catch (std::exception& e) {
83683       {
83684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83685       };
83686     } catch (Dali::DaliException e) {
83687       {
83688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83689       };
83690     } catch (...) {
83691       {
83692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83693       };
83694     }
83695   }
83696
83697 }
83698
83699
83700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83701   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83702   Dali::Size arg2 ;
83703   Dali::Size *argp2 ;
83704
83705   arg1 = (Dali::Toolkit::TableView *)jarg1;
83706   argp2 = (Dali::Size *)jarg2;
83707   if (!argp2) {
83708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83709     return ;
83710   }
83711   arg2 = *argp2;
83712   {
83713     try {
83714       (arg1)->SetCellPadding(arg2);
83715     } catch (std::out_of_range& e) {
83716       {
83717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83718       };
83719     } catch (std::exception& e) {
83720       {
83721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83722       };
83723     } catch (Dali::DaliException e) {
83724       {
83725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83726       };
83727     } catch (...) {
83728       {
83729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83730       };
83731     }
83732   }
83733
83734 }
83735
83736
83737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83738   void * jresult ;
83739   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83740   Dali::Size result;
83741
83742   arg1 = (Dali::Toolkit::TableView *)jarg1;
83743   {
83744     try {
83745       result = (arg1)->GetCellPadding();
83746     } catch (std::out_of_range& e) {
83747       {
83748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83749       };
83750     } catch (std::exception& e) {
83751       {
83752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (Dali::DaliException e) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83761       };
83762     }
83763   }
83764
83765   jresult = new Dali::Size((const Dali::Size &)result);
83766   return jresult;
83767 }
83768
83769
83770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83771   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83772   unsigned int arg2 ;
83773
83774   arg1 = (Dali::Toolkit::TableView *)jarg1;
83775   arg2 = (unsigned int)jarg2;
83776   {
83777     try {
83778       (arg1)->SetFitHeight(arg2);
83779     } catch (std::out_of_range& e) {
83780       {
83781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83782       };
83783     } catch (std::exception& e) {
83784       {
83785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83786       };
83787     } catch (Dali::DaliException e) {
83788       {
83789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83794       };
83795     }
83796   }
83797
83798 }
83799
83800
83801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83802   unsigned int jresult ;
83803   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83804   unsigned int arg2 ;
83805   bool result;
83806
83807   arg1 = (Dali::Toolkit::TableView *)jarg1;
83808   arg2 = (unsigned int)jarg2;
83809   {
83810     try {
83811       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83812     } catch (std::out_of_range& e) {
83813       {
83814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83815       };
83816     } catch (std::exception& e) {
83817       {
83818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83819       };
83820     } catch (Dali::DaliException e) {
83821       {
83822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83823       };
83824     } catch (...) {
83825       {
83826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83827       };
83828     }
83829   }
83830
83831   jresult = result;
83832   return jresult;
83833 }
83834
83835
83836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83837   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83838   unsigned int arg2 ;
83839
83840   arg1 = (Dali::Toolkit::TableView *)jarg1;
83841   arg2 = (unsigned int)jarg2;
83842   {
83843     try {
83844       (arg1)->SetFitWidth(arg2);
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83852       };
83853     } catch (Dali::DaliException e) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83856       };
83857     } catch (...) {
83858       {
83859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83860       };
83861     }
83862   }
83863
83864 }
83865
83866
83867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83868   unsigned int jresult ;
83869   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83870   unsigned int arg2 ;
83871   bool result;
83872
83873   arg1 = (Dali::Toolkit::TableView *)jarg1;
83874   arg2 = (unsigned int)jarg2;
83875   {
83876     try {
83877       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83878     } catch (std::out_of_range& e) {
83879       {
83880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83881       };
83882     } catch (std::exception& e) {
83883       {
83884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83885       };
83886     } catch (Dali::DaliException e) {
83887       {
83888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83889       };
83890     } catch (...) {
83891       {
83892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83893       };
83894     }
83895   }
83896
83897   jresult = result;
83898   return jresult;
83899 }
83900
83901
83902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83903   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83904   unsigned int arg2 ;
83905   float arg3 ;
83906
83907   arg1 = (Dali::Toolkit::TableView *)jarg1;
83908   arg2 = (unsigned int)jarg2;
83909   arg3 = (float)jarg3;
83910   {
83911     try {
83912       (arg1)->SetFixedHeight(arg2,arg3);
83913     } catch (std::out_of_range& e) {
83914       {
83915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83916       };
83917     } catch (std::exception& e) {
83918       {
83919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83920       };
83921     } catch (Dali::DaliException e) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83924       };
83925     } catch (...) {
83926       {
83927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83928       };
83929     }
83930   }
83931
83932 }
83933
83934
83935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83936   float jresult ;
83937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83938   unsigned int arg2 ;
83939   float result;
83940
83941   arg1 = (Dali::Toolkit::TableView *)jarg1;
83942   arg2 = (unsigned int)jarg2;
83943   {
83944     try {
83945       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83946     } catch (std::out_of_range& e) {
83947       {
83948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83949       };
83950     } catch (std::exception& e) {
83951       {
83952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83953       };
83954     } catch (Dali::DaliException e) {
83955       {
83956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83957       };
83958     } catch (...) {
83959       {
83960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83961       };
83962     }
83963   }
83964
83965   jresult = result;
83966   return jresult;
83967 }
83968
83969
83970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83971   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83972   unsigned int arg2 ;
83973   float arg3 ;
83974
83975   arg1 = (Dali::Toolkit::TableView *)jarg1;
83976   arg2 = (unsigned int)jarg2;
83977   arg3 = (float)jarg3;
83978   {
83979     try {
83980       (arg1)->SetRelativeHeight(arg2,arg3);
83981     } catch (std::out_of_range& e) {
83982       {
83983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83984       };
83985     } catch (std::exception& e) {
83986       {
83987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83988       };
83989     } catch (Dali::DaliException e) {
83990       {
83991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83992       };
83993     } catch (...) {
83994       {
83995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83996       };
83997     }
83998   }
83999
84000 }
84001
84002
84003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84004   float jresult ;
84005   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84006   unsigned int arg2 ;
84007   float result;
84008
84009   arg1 = (Dali::Toolkit::TableView *)jarg1;
84010   arg2 = (unsigned int)jarg2;
84011   {
84012     try {
84013       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84014     } catch (std::out_of_range& e) {
84015       {
84016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84017       };
84018     } catch (std::exception& e) {
84019       {
84020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84021       };
84022     } catch (Dali::DaliException e) {
84023       {
84024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84025       };
84026     } catch (...) {
84027       {
84028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84029       };
84030     }
84031   }
84032
84033   jresult = result;
84034   return jresult;
84035 }
84036
84037
84038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84039   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84040   unsigned int arg2 ;
84041   float arg3 ;
84042
84043   arg1 = (Dali::Toolkit::TableView *)jarg1;
84044   arg2 = (unsigned int)jarg2;
84045   arg3 = (float)jarg3;
84046   {
84047     try {
84048       (arg1)->SetFixedWidth(arg2,arg3);
84049     } catch (std::out_of_range& e) {
84050       {
84051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84052       };
84053     } catch (std::exception& e) {
84054       {
84055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84056       };
84057     } catch (Dali::DaliException e) {
84058       {
84059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84064       };
84065     }
84066   }
84067
84068 }
84069
84070
84071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84072   float jresult ;
84073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84074   unsigned int arg2 ;
84075   float result;
84076
84077   arg1 = (Dali::Toolkit::TableView *)jarg1;
84078   arg2 = (unsigned int)jarg2;
84079   {
84080     try {
84081       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84082     } catch (std::out_of_range& e) {
84083       {
84084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84085       };
84086     } catch (std::exception& e) {
84087       {
84088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84089       };
84090     } catch (Dali::DaliException e) {
84091       {
84092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84093       };
84094     } catch (...) {
84095       {
84096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84097       };
84098     }
84099   }
84100
84101   jresult = result;
84102   return jresult;
84103 }
84104
84105
84106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84107   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84108   unsigned int arg2 ;
84109   float arg3 ;
84110
84111   arg1 = (Dali::Toolkit::TableView *)jarg1;
84112   arg2 = (unsigned int)jarg2;
84113   arg3 = (float)jarg3;
84114   {
84115     try {
84116       (arg1)->SetRelativeWidth(arg2,arg3);
84117     } catch (std::out_of_range& e) {
84118       {
84119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84120       };
84121     } catch (std::exception& e) {
84122       {
84123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84124       };
84125     } catch (Dali::DaliException e) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84132       };
84133     }
84134   }
84135
84136 }
84137
84138
84139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84140   float jresult ;
84141   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84142   unsigned int arg2 ;
84143   float result;
84144
84145   arg1 = (Dali::Toolkit::TableView *)jarg1;
84146   arg2 = (unsigned int)jarg2;
84147   {
84148     try {
84149       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84150     } catch (std::out_of_range& e) {
84151       {
84152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84153       };
84154     } catch (std::exception& e) {
84155       {
84156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84157       };
84158     } catch (Dali::DaliException e) {
84159       {
84160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84161       };
84162     } catch (...) {
84163       {
84164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84165       };
84166     }
84167   }
84168
84169   jresult = result;
84170   return jresult;
84171 }
84172
84173
84174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84175   unsigned int jresult ;
84176   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84177   unsigned int result;
84178
84179   arg1 = (Dali::Toolkit::TableView *)jarg1;
84180   {
84181     try {
84182       result = (unsigned int)(arg1)->GetRows();
84183     } catch (std::out_of_range& e) {
84184       {
84185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84186       };
84187     } catch (std::exception& e) {
84188       {
84189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84190       };
84191     } catch (Dali::DaliException e) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84194       };
84195     } catch (...) {
84196       {
84197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84198       };
84199     }
84200   }
84201
84202   jresult = result;
84203   return jresult;
84204 }
84205
84206
84207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84208   unsigned int jresult ;
84209   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84210   unsigned int result;
84211
84212   arg1 = (Dali::Toolkit::TableView *)jarg1;
84213   {
84214     try {
84215       result = (unsigned int)(arg1)->GetColumns();
84216     } catch (std::out_of_range& e) {
84217       {
84218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84219       };
84220     } catch (std::exception& e) {
84221       {
84222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84223       };
84224     } catch (Dali::DaliException e) {
84225       {
84226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84227       };
84228     } catch (...) {
84229       {
84230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84231       };
84232     }
84233   }
84234
84235   jresult = result;
84236   return jresult;
84237 }
84238
84239
84240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84241   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84242   Dali::Toolkit::TableView::CellPosition arg2 ;
84243   Dali::HorizontalAlignment::Type arg3 ;
84244   Dali::VerticalAlignment::Type arg4 ;
84245   Dali::Toolkit::TableView::CellPosition *argp2 ;
84246
84247   arg1 = (Dali::Toolkit::TableView *)jarg1;
84248   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84249   if (!argp2) {
84250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84251     return ;
84252   }
84253   arg2 = *argp2;
84254   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84255   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84256   {
84257     try {
84258       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84259     } catch (std::out_of_range& e) {
84260       {
84261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84262       };
84263     } catch (std::exception& e) {
84264       {
84265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84266       };
84267     } catch (Dali::DaliException e) {
84268       {
84269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84270       };
84271     } catch (...) {
84272       {
84273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84274       };
84275     }
84276   }
84277
84278 }
84279
84280
84281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84282   unsigned int jresult ;
84283   unsigned int result;
84284
84285   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84286   jresult = result;
84287   return jresult;
84288 }
84289
84290
84291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84292   int jresult ;
84293   int result;
84294
84295   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84296   jresult = (int)result;
84297   return jresult;
84298 }
84299
84300
84301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84302   int jresult ;
84303   int result;
84304
84305   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84306   jresult = (int)result;
84307   return jresult;
84308 }
84309
84310
84311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84312   int jresult ;
84313   int result;
84314
84315   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84316   jresult = (int)result;
84317   return jresult;
84318 }
84319
84320
84321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84322   int jresult ;
84323   int result;
84324
84325   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84326   jresult = (int)result;
84327   return jresult;
84328 }
84329
84330
84331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84332   int jresult ;
84333   int result;
84334
84335   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84336   jresult = (int)result;
84337   return jresult;
84338 }
84339
84340
84341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84342   int jresult ;
84343   int result;
84344
84345   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84346   jresult = (int)result;
84347   return jresult;
84348 }
84349
84350
84351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84352   int jresult ;
84353   int result;
84354
84355   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84356   jresult = (int)result;
84357   return jresult;
84358 }
84359
84360
84361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84362   int jresult ;
84363   int result;
84364
84365   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84366   jresult = (int)result;
84367   return jresult;
84368 }
84369
84370
84371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84372   int jresult ;
84373   int result;
84374
84375   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84376   jresult = (int)result;
84377   return jresult;
84378 }
84379
84380
84381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84382   int jresult ;
84383   int result;
84384
84385   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84386   jresult = (int)result;
84387   return jresult;
84388 }
84389
84390
84391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84392   int jresult ;
84393   int result;
84394
84395   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84396   jresult = (int)result;
84397   return jresult;
84398 }
84399
84400
84401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84402   int jresult ;
84403   int result;
84404
84405   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84406   jresult = (int)result;
84407   return jresult;
84408 }
84409
84410
84411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84412   int jresult ;
84413   int result;
84414
84415   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84416   jresult = (int)result;
84417   return jresult;
84418 }
84419
84420
84421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84422   int jresult ;
84423   int result;
84424
84425   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84426   jresult = (int)result;
84427   return jresult;
84428 }
84429
84430
84431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84432   int jresult ;
84433   int result;
84434
84435   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84436   jresult = (int)result;
84437   return jresult;
84438 }
84439
84440
84441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84442   int jresult ;
84443   int result;
84444
84445   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84446   jresult = (int)result;
84447   return jresult;
84448 }
84449
84450
84451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84452   int jresult ;
84453   int result;
84454
84455   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84456   jresult = (int)result;
84457   return jresult;
84458 }
84459
84460
84461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84462   int jresult ;
84463   int result;
84464
84465   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84466   jresult = (int)result;
84467   return jresult;
84468 }
84469
84470
84471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84472   int jresult ;
84473   int result;
84474
84475   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84476   jresult = (int)result;
84477   return jresult;
84478 }
84479
84480
84481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84482   void * jresult ;
84483   Dali::Toolkit::TextLabel::Property *result = 0 ;
84484
84485   {
84486     try {
84487       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84488     } catch (std::out_of_range& e) {
84489       {
84490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84491       };
84492     } catch (std::exception& e) {
84493       {
84494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84495       };
84496     } catch (Dali::DaliException e) {
84497       {
84498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84499       };
84500     } catch (...) {
84501       {
84502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84503       };
84504     }
84505   }
84506
84507   jresult = (void *)result;
84508   return jresult;
84509 }
84510
84511
84512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84513   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84514
84515   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84516   {
84517     try {
84518       delete arg1;
84519     } catch (std::out_of_range& e) {
84520       {
84521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84522       };
84523     } catch (std::exception& e) {
84524       {
84525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84526       };
84527     } catch (Dali::DaliException e) {
84528       {
84529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84530       };
84531     } catch (...) {
84532       {
84533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84534       };
84535     }
84536   }
84537
84538 }
84539
84540
84541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84542   void * jresult ;
84543   Dali::Toolkit::TextLabel result;
84544
84545   {
84546     try {
84547       result = Dali::Toolkit::TextLabel::New();
84548     } catch (std::out_of_range& e) {
84549       {
84550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84551       };
84552     } catch (std::exception& e) {
84553       {
84554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84555       };
84556     } catch (Dali::DaliException e) {
84557       {
84558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84559       };
84560     } catch (...) {
84561       {
84562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84563       };
84564     }
84565   }
84566
84567   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84568   return jresult;
84569 }
84570
84571
84572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84573   void * jresult ;
84574   std::string *arg1 = 0 ;
84575   Dali::Toolkit::TextLabel result;
84576
84577   if (!jarg1) {
84578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84579     return 0;
84580   }
84581   std::string arg1_str(jarg1);
84582   arg1 = &arg1_str;
84583   {
84584     try {
84585       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84586     } catch (std::out_of_range& e) {
84587       {
84588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84589       };
84590     } catch (std::exception& e) {
84591       {
84592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84593       };
84594     } catch (Dali::DaliException e) {
84595       {
84596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84597       };
84598     } catch (...) {
84599       {
84600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84601       };
84602     }
84603   }
84604
84605   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84606
84607   //argout typemap for const std::string&
84608
84609   return jresult;
84610 }
84611
84612
84613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84614   void * jresult ;
84615   Dali::Toolkit::TextLabel *result = 0 ;
84616
84617   {
84618     try {
84619       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84620     } catch (std::out_of_range& e) {
84621       {
84622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84623       };
84624     } catch (std::exception& e) {
84625       {
84626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84627       };
84628     } catch (Dali::DaliException e) {
84629       {
84630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84631       };
84632     } catch (...) {
84633       {
84634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84635       };
84636     }
84637   }
84638
84639   jresult = (void *)result;
84640   return jresult;
84641 }
84642
84643
84644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84645   void * jresult ;
84646   Dali::Toolkit::TextLabel *arg1 = 0 ;
84647   Dali::Toolkit::TextLabel *result = 0 ;
84648
84649   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84650   if (!arg1) {
84651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84652     return 0;
84653   }
84654   {
84655     try {
84656       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84657     } catch (std::out_of_range& e) {
84658       {
84659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84660       };
84661     } catch (std::exception& e) {
84662       {
84663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84664       };
84665     } catch (Dali::DaliException e) {
84666       {
84667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84668       };
84669     } catch (...) {
84670       {
84671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84672       };
84673     }
84674   }
84675
84676   jresult = (void *)result;
84677   return jresult;
84678 }
84679
84680
84681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84682   void * jresult ;
84683   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84684   Dali::Toolkit::TextLabel *arg2 = 0 ;
84685   Dali::Toolkit::TextLabel *result = 0 ;
84686
84687   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84688   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84689   if (!arg2) {
84690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84691     return 0;
84692   }
84693   {
84694     try {
84695       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84696     } catch (std::out_of_range& e) {
84697       {
84698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84699       };
84700     } catch (std::exception& e) {
84701       {
84702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84703       };
84704     } catch (Dali::DaliException e) {
84705       {
84706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84707       };
84708     } catch (...) {
84709       {
84710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84711       };
84712     }
84713   }
84714
84715   jresult = (void *)result;
84716   return jresult;
84717 }
84718
84719
84720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84721   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84722
84723   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84724   {
84725     try {
84726       delete arg1;
84727     } catch (std::out_of_range& e) {
84728       {
84729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84730       };
84731     } catch (std::exception& e) {
84732       {
84733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84734       };
84735     } catch (Dali::DaliException e) {
84736       {
84737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84738       };
84739     } catch (...) {
84740       {
84741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84742       };
84743     }
84744   }
84745
84746 }
84747
84748
84749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84750   void * jresult ;
84751   Dali::BaseHandle arg1 ;
84752   Dali::BaseHandle *argp1 ;
84753   Dali::Toolkit::TextLabel result;
84754
84755   argp1 = (Dali::BaseHandle *)jarg1;
84756   if (!argp1) {
84757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84758     return 0;
84759   }
84760   arg1 = *argp1;
84761   {
84762     try {
84763       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84764     } catch (std::out_of_range& e) {
84765       {
84766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84767       };
84768     } catch (std::exception& e) {
84769       {
84770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84771       };
84772     } catch (Dali::DaliException e) {
84773       {
84774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84775       };
84776     } catch (...) {
84777       {
84778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84779       };
84780     }
84781   }
84782
84783   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84784   return jresult;
84785 }
84786
84787
84788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84789   void * jresult ;
84790   Dali::Toolkit::AccessibilityManager *result = 0 ;
84791
84792   {
84793     try {
84794       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84795     } catch (std::out_of_range& e) {
84796       {
84797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84798       };
84799     } catch (std::exception& e) {
84800       {
84801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84802       };
84803     } catch (Dali::DaliException e) {
84804       {
84805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84806       };
84807     } catch (...) {
84808       {
84809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84810       };
84811     }
84812   }
84813
84814   jresult = (void *)result;
84815   return jresult;
84816 }
84817
84818
84819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84820   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84821
84822   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84823   {
84824     try {
84825       delete arg1;
84826     } catch (std::out_of_range& e) {
84827       {
84828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84829       };
84830     } catch (std::exception& e) {
84831       {
84832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84833       };
84834     } catch (Dali::DaliException e) {
84835       {
84836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84837       };
84838     } catch (...) {
84839       {
84840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84841       };
84842     }
84843   }
84844
84845 }
84846
84847
84848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84849   void * jresult ;
84850   Dali::Toolkit::AccessibilityManager result;
84851
84852   {
84853     try {
84854       result = Dali::Toolkit::AccessibilityManager::Get();
84855     } catch (std::out_of_range& e) {
84856       {
84857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84858       };
84859     } catch (std::exception& e) {
84860       {
84861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84862       };
84863     } catch (Dali::DaliException e) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84866       };
84867     } catch (...) {
84868       {
84869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84870       };
84871     }
84872   }
84873
84874   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84875   return jresult;
84876 }
84877
84878
84879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84880   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84881   Dali::Actor arg2 ;
84882   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84883   std::string *arg4 = 0 ;
84884   Dali::Actor *argp2 ;
84885
84886   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84887   argp2 = (Dali::Actor *)jarg2;
84888   if (!argp2) {
84889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84890     return ;
84891   }
84892   arg2 = *argp2;
84893   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84894   if (!jarg4) {
84895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84896     return ;
84897   }
84898   std::string arg4_str(jarg4);
84899   arg4 = &arg4_str;
84900   {
84901     try {
84902       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84903     } catch (std::out_of_range& e) {
84904       {
84905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84906       };
84907     } catch (std::exception& e) {
84908       {
84909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84910       };
84911     } catch (Dali::DaliException e) {
84912       {
84913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84914       };
84915     } catch (...) {
84916       {
84917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84918       };
84919     }
84920   }
84921
84922
84923   //argout typemap for const std::string&
84924
84925 }
84926
84927
84928 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84929   char * jresult ;
84930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84931   Dali::Actor arg2 ;
84932   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84933   Dali::Actor *argp2 ;
84934   std::string result;
84935
84936   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84937   argp2 = (Dali::Actor *)jarg2;
84938   if (!argp2) {
84939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84940     return 0;
84941   }
84942   arg2 = *argp2;
84943   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84944   {
84945     try {
84946       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84947     } catch (std::out_of_range& e) {
84948       {
84949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (std::exception& e) {
84952       {
84953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84954       };
84955     } catch (Dali::DaliException e) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84958       };
84959     } catch (...) {
84960       {
84961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84962       };
84963     }
84964   }
84965
84966   jresult = SWIG_csharp_string_callback((&result)->c_str());
84967   return jresult;
84968 }
84969
84970
84971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84972   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84973   Dali::Actor arg2 ;
84974   unsigned int arg3 ;
84975   Dali::Actor *argp2 ;
84976
84977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84978   argp2 = (Dali::Actor *)jarg2;
84979   if (!argp2) {
84980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84981     return ;
84982   }
84983   arg2 = *argp2;
84984   arg3 = (unsigned int)jarg3;
84985   {
84986     try {
84987       (arg1)->SetFocusOrder(arg2,arg3);
84988     } catch (std::out_of_range& e) {
84989       {
84990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84991       };
84992     } catch (std::exception& e) {
84993       {
84994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84995       };
84996     } catch (Dali::DaliException e) {
84997       {
84998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84999       };
85000     } catch (...) {
85001       {
85002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85003       };
85004     }
85005   }
85006
85007 }
85008
85009
85010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85011   unsigned int jresult ;
85012   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85013   Dali::Actor arg2 ;
85014   Dali::Actor *argp2 ;
85015   unsigned int result;
85016
85017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85018   argp2 = (Dali::Actor *)jarg2;
85019   if (!argp2) {
85020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85021     return 0;
85022   }
85023   arg2 = *argp2;
85024   {
85025     try {
85026       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85027     } catch (std::out_of_range& e) {
85028       {
85029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85030       };
85031     } catch (std::exception& e) {
85032       {
85033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85034       };
85035     } catch (Dali::DaliException e) {
85036       {
85037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85038       };
85039     } catch (...) {
85040       {
85041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85042       };
85043     }
85044   }
85045
85046   jresult = result;
85047   return jresult;
85048 }
85049
85050
85051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85052   unsigned int jresult ;
85053   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85054   unsigned int result;
85055
85056   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85057   {
85058     try {
85059       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85060     } catch (std::out_of_range& e) {
85061       {
85062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85063       };
85064     } catch (std::exception& e) {
85065       {
85066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85067       };
85068     } catch (Dali::DaliException e) {
85069       {
85070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85071       };
85072     } catch (...) {
85073       {
85074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85075       };
85076     }
85077   }
85078
85079   jresult = result;
85080   return jresult;
85081 }
85082
85083
85084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85085   void * jresult ;
85086   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85087   unsigned int arg2 ;
85088   Dali::Actor result;
85089
85090   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85091   arg2 = (unsigned int)jarg2;
85092   {
85093     try {
85094       result = (arg1)->GetActorByFocusOrder(arg2);
85095     } catch (std::out_of_range& e) {
85096       {
85097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85098       };
85099     } catch (std::exception& e) {
85100       {
85101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85102       };
85103     } catch (Dali::DaliException e) {
85104       {
85105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85106       };
85107     } catch (...) {
85108       {
85109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85110       };
85111     }
85112   }
85113
85114   jresult = new Dali::Actor((const Dali::Actor &)result);
85115   return jresult;
85116 }
85117
85118
85119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85120   unsigned int jresult ;
85121   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85122   Dali::Actor arg2 ;
85123   Dali::Actor *argp2 ;
85124   bool result;
85125
85126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85127   argp2 = (Dali::Actor *)jarg2;
85128   if (!argp2) {
85129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85130     return 0;
85131   }
85132   arg2 = *argp2;
85133   {
85134     try {
85135       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85136     } catch (std::out_of_range& e) {
85137       {
85138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85139       };
85140     } catch (std::exception& e) {
85141       {
85142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85143       };
85144     } catch (Dali::DaliException e) {
85145       {
85146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85147       };
85148     } catch (...) {
85149       {
85150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85151       };
85152     }
85153   }
85154
85155   jresult = result;
85156   return jresult;
85157 }
85158
85159
85160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85161   void * jresult ;
85162   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85163   Dali::Actor result;
85164
85165   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85166   {
85167     try {
85168       result = (arg1)->GetCurrentFocusActor();
85169     } catch (std::out_of_range& e) {
85170       {
85171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85172       };
85173     } catch (std::exception& e) {
85174       {
85175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (Dali::DaliException e) {
85178       {
85179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85180       };
85181     } catch (...) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85184       };
85185     }
85186   }
85187
85188   jresult = new Dali::Actor((const Dali::Actor &)result);
85189   return jresult;
85190 }
85191
85192
85193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85194   void * jresult ;
85195   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85196   Dali::Actor result;
85197
85198   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85199   {
85200     try {
85201       result = (arg1)->GetCurrentFocusGroup();
85202     } catch (std::out_of_range& e) {
85203       {
85204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85205       };
85206     } catch (std::exception& e) {
85207       {
85208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (Dali::DaliException e) {
85211       {
85212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85213       };
85214     } catch (...) {
85215       {
85216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85217       };
85218     }
85219   }
85220
85221   jresult = new Dali::Actor((const Dali::Actor &)result);
85222   return jresult;
85223 }
85224
85225
85226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85227   unsigned int jresult ;
85228   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85229   unsigned int result;
85230
85231   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85232   {
85233     try {
85234       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85235     } catch (std::out_of_range& e) {
85236       {
85237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85238       };
85239     } catch (std::exception& e) {
85240       {
85241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85242       };
85243     } catch (Dali::DaliException e) {
85244       {
85245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85246       };
85247     } catch (...) {
85248       {
85249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85250       };
85251     }
85252   }
85253
85254   jresult = result;
85255   return jresult;
85256 }
85257
85258
85259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85260   unsigned int jresult ;
85261   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85262   bool result;
85263
85264   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85265   {
85266     try {
85267       result = (bool)(arg1)->MoveFocusForward();
85268     } catch (std::out_of_range& e) {
85269       {
85270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85271       };
85272     } catch (std::exception& e) {
85273       {
85274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85275       };
85276     } catch (Dali::DaliException e) {
85277       {
85278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85279       };
85280     } catch (...) {
85281       {
85282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85283       };
85284     }
85285   }
85286
85287   jresult = result;
85288   return jresult;
85289 }
85290
85291
85292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85293   unsigned int jresult ;
85294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85295   bool result;
85296
85297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85298   {
85299     try {
85300       result = (bool)(arg1)->MoveFocusBackward();
85301     } catch (std::out_of_range& e) {
85302       {
85303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85304       };
85305     } catch (std::exception& e) {
85306       {
85307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85308       };
85309     } catch (Dali::DaliException e) {
85310       {
85311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85312       };
85313     } catch (...) {
85314       {
85315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85316       };
85317     }
85318   }
85319
85320   jresult = result;
85321   return jresult;
85322 }
85323
85324
85325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85327
85328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85329   {
85330     try {
85331       (arg1)->ClearFocus();
85332     } catch (std::out_of_range& e) {
85333       {
85334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85335       };
85336     } catch (std::exception& e) {
85337       {
85338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85339       };
85340     } catch (Dali::DaliException e) {
85341       {
85342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85343       };
85344     } catch (...) {
85345       {
85346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85347       };
85348     }
85349   }
85350
85351 }
85352
85353
85354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85355   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85356
85357   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85358   {
85359     try {
85360       (arg1)->Reset();
85361     } catch (std::out_of_range& e) {
85362       {
85363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85364       };
85365     } catch (std::exception& e) {
85366       {
85367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85368       };
85369     } catch (Dali::DaliException e) {
85370       {
85371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85372       };
85373     } catch (...) {
85374       {
85375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85376       };
85377     }
85378   }
85379
85380 }
85381
85382
85383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85384   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85385   Dali::Actor arg2 ;
85386   bool arg3 ;
85387   Dali::Actor *argp2 ;
85388
85389   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85390   argp2 = (Dali::Actor *)jarg2;
85391   if (!argp2) {
85392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85393     return ;
85394   }
85395   arg2 = *argp2;
85396   arg3 = jarg3 ? true : false;
85397   {
85398     try {
85399       (arg1)->SetFocusGroup(arg2,arg3);
85400     } catch (std::out_of_range& e) {
85401       {
85402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85403       };
85404     } catch (std::exception& e) {
85405       {
85406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85407       };
85408     } catch (Dali::DaliException e) {
85409       {
85410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85411       };
85412     } catch (...) {
85413       {
85414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85415       };
85416     }
85417   }
85418
85419 }
85420
85421
85422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85423   unsigned int jresult ;
85424   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85425   Dali::Actor arg2 ;
85426   Dali::Actor *argp2 ;
85427   bool result;
85428
85429   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85430   argp2 = (Dali::Actor *)jarg2;
85431   if (!argp2) {
85432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85433     return 0;
85434   }
85435   arg2 = *argp2;
85436   {
85437     try {
85438       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85439     } catch (std::out_of_range& e) {
85440       {
85441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85442       };
85443     } catch (std::exception& e) {
85444       {
85445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85446       };
85447     } catch (Dali::DaliException e) {
85448       {
85449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85450       };
85451     } catch (...) {
85452       {
85453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85454       };
85455     }
85456   }
85457
85458   jresult = result;
85459   return jresult;
85460 }
85461
85462
85463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85464   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85465   bool arg2 ;
85466
85467   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85468   arg2 = jarg2 ? true : false;
85469   {
85470     try {
85471       (arg1)->SetGroupMode(arg2);
85472     } catch (std::out_of_range& e) {
85473       {
85474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85475       };
85476     } catch (std::exception& e) {
85477       {
85478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85479       };
85480     } catch (Dali::DaliException e) {
85481       {
85482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85483       };
85484     } catch (...) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85487       };
85488     }
85489   }
85490
85491 }
85492
85493
85494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85495   unsigned int jresult ;
85496   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85497   bool result;
85498
85499   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85500   {
85501     try {
85502       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85503     } catch (std::out_of_range& e) {
85504       {
85505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85506       };
85507     } catch (std::exception& e) {
85508       {
85509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85510       };
85511     } catch (Dali::DaliException e) {
85512       {
85513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85514       };
85515     } catch (...) {
85516       {
85517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85518       };
85519     }
85520   }
85521
85522   jresult = result;
85523   return jresult;
85524 }
85525
85526
85527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85528   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85529   bool arg2 ;
85530
85531   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85532   arg2 = jarg2 ? true : false;
85533   {
85534     try {
85535       (arg1)->SetWrapMode(arg2);
85536     } catch (std::out_of_range& e) {
85537       {
85538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85539       };
85540     } catch (std::exception& e) {
85541       {
85542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85543       };
85544     } catch (Dali::DaliException e) {
85545       {
85546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85547       };
85548     } catch (...) {
85549       {
85550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85551       };
85552     }
85553   }
85554
85555 }
85556
85557
85558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85559   unsigned int jresult ;
85560   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85561   bool result;
85562
85563   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85564   {
85565     try {
85566       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85567     } catch (std::out_of_range& e) {
85568       {
85569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85570       };
85571     } catch (std::exception& e) {
85572       {
85573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85574       };
85575     } catch (Dali::DaliException e) {
85576       {
85577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85578       };
85579     } catch (...) {
85580       {
85581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85582       };
85583     }
85584   }
85585
85586   jresult = result;
85587   return jresult;
85588 }
85589
85590
85591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85592   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85593   Dali::Actor arg2 ;
85594   Dali::Actor *argp2 ;
85595
85596   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85597   argp2 = (Dali::Actor *)jarg2;
85598   if (!argp2) {
85599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85600     return ;
85601   }
85602   arg2 = *argp2;
85603   {
85604     try {
85605       (arg1)->SetFocusIndicatorActor(arg2);
85606     } catch (std::out_of_range& e) {
85607       {
85608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85609       };
85610     } catch (std::exception& e) {
85611       {
85612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85613       };
85614     } catch (Dali::DaliException e) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85617       };
85618     } catch (...) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85621       };
85622     }
85623   }
85624
85625 }
85626
85627
85628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85629   void * jresult ;
85630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85631   Dali::Actor result;
85632
85633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85634   {
85635     try {
85636       result = (arg1)->GetFocusIndicatorActor();
85637     } catch (std::out_of_range& e) {
85638       {
85639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85640       };
85641     } catch (std::exception& e) {
85642       {
85643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85644       };
85645     } catch (Dali::DaliException e) {
85646       {
85647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85648       };
85649     } catch (...) {
85650       {
85651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85652       };
85653     }
85654   }
85655
85656   jresult = new Dali::Actor((const Dali::Actor &)result);
85657   return jresult;
85658 }
85659
85660
85661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85662   void * jresult ;
85663   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85664   Dali::Actor arg2 ;
85665   Dali::Actor *argp2 ;
85666   Dali::Actor result;
85667
85668   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85669   argp2 = (Dali::Actor *)jarg2;
85670   if (!argp2) {
85671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85672     return 0;
85673   }
85674   arg2 = *argp2;
85675   {
85676     try {
85677       result = (arg1)->GetFocusGroup(arg2);
85678     } catch (std::out_of_range& e) {
85679       {
85680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85681       };
85682     } catch (std::exception& e) {
85683       {
85684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85685       };
85686     } catch (Dali::DaliException e) {
85687       {
85688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85689       };
85690     } catch (...) {
85691       {
85692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85693       };
85694     }
85695   }
85696
85697   jresult = new Dali::Actor((const Dali::Actor &)result);
85698   return jresult;
85699 }
85700
85701
85702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85703   void * jresult ;
85704   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85705   Dali::Vector2 result;
85706
85707   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85708   {
85709     try {
85710       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85711     } catch (std::out_of_range& e) {
85712       {
85713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85714       };
85715     } catch (std::exception& e) {
85716       {
85717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85718       };
85719     } catch (Dali::DaliException e) {
85720       {
85721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85722       };
85723     } catch (...) {
85724       {
85725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85726       };
85727     }
85728   }
85729
85730   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85731   return jresult;
85732 }
85733
85734
85735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85736   void * jresult ;
85737   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85738   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85739
85740   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85741   {
85742     try {
85743       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85744     } catch (std::out_of_range& e) {
85745       {
85746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85747       };
85748     } catch (std::exception& e) {
85749       {
85750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85751       };
85752     } catch (Dali::DaliException e) {
85753       {
85754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85755       };
85756     } catch (...) {
85757       {
85758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85759       };
85760     }
85761   }
85762
85763   jresult = (void *)result;
85764   return jresult;
85765 }
85766
85767
85768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85769   void * jresult ;
85770   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85771   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85772
85773   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85774   {
85775     try {
85776       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85777     } catch (std::out_of_range& e) {
85778       {
85779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85780       };
85781     } catch (std::exception& e) {
85782       {
85783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85784       };
85785     } catch (Dali::DaliException e) {
85786       {
85787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85788       };
85789     } catch (...) {
85790       {
85791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85792       };
85793     }
85794   }
85795
85796   jresult = (void *)result;
85797   return jresult;
85798 }
85799
85800
85801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85802   void * jresult ;
85803   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85804   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85805
85806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85807   {
85808     try {
85809       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85810     } catch (std::out_of_range& e) {
85811       {
85812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85813       };
85814     } catch (std::exception& e) {
85815       {
85816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85817       };
85818     } catch (Dali::DaliException e) {
85819       {
85820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85821       };
85822     } catch (...) {
85823       {
85824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85825       };
85826     }
85827   }
85828
85829   jresult = (void *)result;
85830   return jresult;
85831 }
85832
85833
85834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85835   void * jresult ;
85836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85837   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85838
85839   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85840   {
85841     try {
85842       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85843     } catch (std::out_of_range& e) {
85844       {
85845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85846       };
85847     } catch (std::exception& e) {
85848       {
85849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85850       };
85851     } catch (Dali::DaliException e) {
85852       {
85853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85854       };
85855     } catch (...) {
85856       {
85857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85858       };
85859     }
85860   }
85861
85862   jresult = (void *)result;
85863   return jresult;
85864 }
85865
85866
85867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85868   void * jresult ;
85869   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85870   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85871
85872   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85873   {
85874     try {
85875       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85876     } catch (std::out_of_range& e) {
85877       {
85878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85879       };
85880     } catch (std::exception& e) {
85881       {
85882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85883       };
85884     } catch (Dali::DaliException e) {
85885       {
85886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85887       };
85888     } catch (...) {
85889       {
85890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85891       };
85892     }
85893   }
85894
85895   jresult = (void *)result;
85896   return jresult;
85897 }
85898
85899
85900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85901   void * jresult ;
85902   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85903   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85904
85905   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85906   {
85907     try {
85908       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85909     } catch (std::out_of_range& e) {
85910       {
85911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85912       };
85913     } catch (std::exception& e) {
85914       {
85915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85916       };
85917     } catch (Dali::DaliException e) {
85918       {
85919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85920       };
85921     } catch (...) {
85922       {
85923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85924       };
85925     }
85926   }
85927
85928   jresult = (void *)result;
85929   return jresult;
85930 }
85931
85932
85933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85934   void * jresult ;
85935   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85936   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85937
85938   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85939   {
85940     try {
85941       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85942     } catch (std::out_of_range& e) {
85943       {
85944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85945       };
85946     } catch (std::exception& e) {
85947       {
85948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85949       };
85950     } catch (Dali::DaliException e) {
85951       {
85952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85953       };
85954     } catch (...) {
85955       {
85956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85957       };
85958     }
85959   }
85960
85961   jresult = (void *)result;
85962   return jresult;
85963 }
85964
85965
85966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85967   void * jresult ;
85968   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85969   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85970
85971   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85972   {
85973     try {
85974       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85975     } catch (std::out_of_range& e) {
85976       {
85977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85978       };
85979     } catch (std::exception& e) {
85980       {
85981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85982       };
85983     } catch (Dali::DaliException e) {
85984       {
85985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85986       };
85987     } catch (...) {
85988       {
85989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85990       };
85991     }
85992   }
85993
85994   jresult = (void *)result;
85995   return jresult;
85996 }
85997
85998
85999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86000   void * jresult ;
86001   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86002   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86003
86004   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86005   {
86006     try {
86007       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86008     } catch (std::out_of_range& e) {
86009       {
86010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86011       };
86012     } catch (std::exception& e) {
86013       {
86014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86015       };
86016     } catch (Dali::DaliException e) {
86017       {
86018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86019       };
86020     } catch (...) {
86021       {
86022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86023       };
86024     }
86025   }
86026
86027   jresult = (void *)result;
86028   return jresult;
86029 }
86030
86031
86032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86033   void * jresult ;
86034   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86035   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86036
86037   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86038   {
86039     try {
86040       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86041     } catch (std::out_of_range& e) {
86042       {
86043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86044       };
86045     } catch (std::exception& e) {
86046       {
86047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86048       };
86049     } catch (Dali::DaliException e) {
86050       {
86051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86052       };
86053     } catch (...) {
86054       {
86055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86056       };
86057     }
86058   }
86059
86060   jresult = (void *)result;
86061   return jresult;
86062 }
86063
86064
86065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86066   void * jresult ;
86067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86068   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86069
86070   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86071   {
86072     try {
86073       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86074     } catch (std::out_of_range& e) {
86075       {
86076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86077       };
86078     } catch (std::exception& e) {
86079       {
86080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86081       };
86082     } catch (Dali::DaliException e) {
86083       {
86084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86085       };
86086     } catch (...) {
86087       {
86088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86089       };
86090     }
86091   }
86092
86093   jresult = (void *)result;
86094   return jresult;
86095 }
86096
86097
86098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86099   void * jresult ;
86100   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86101   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86102
86103   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86104   {
86105     try {
86106       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86107     } catch (std::out_of_range& e) {
86108       {
86109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86110       };
86111     } catch (std::exception& e) {
86112       {
86113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86114       };
86115     } catch (Dali::DaliException e) {
86116       {
86117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86118       };
86119     } catch (...) {
86120       {
86121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86122       };
86123     }
86124   }
86125
86126   jresult = (void *)result;
86127   return jresult;
86128 }
86129
86130
86131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86132   void * jresult ;
86133   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86134   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86135
86136   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86137   {
86138     try {
86139       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86140     } catch (std::out_of_range& e) {
86141       {
86142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86143       };
86144     } catch (std::exception& e) {
86145       {
86146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86147       };
86148     } catch (Dali::DaliException e) {
86149       {
86150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86151       };
86152     } catch (...) {
86153       {
86154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86155       };
86156     }
86157   }
86158
86159   jresult = (void *)result;
86160   return jresult;
86161 }
86162
86163
86164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86165   void * jresult ;
86166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86167   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86168
86169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86170   {
86171     try {
86172       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86173     } catch (std::out_of_range& e) {
86174       {
86175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86176       };
86177     } catch (std::exception& e) {
86178       {
86179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86180       };
86181     } catch (Dali::DaliException e) {
86182       {
86183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86184       };
86185     } catch (...) {
86186       {
86187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86188       };
86189     }
86190   }
86191
86192   jresult = (void *)result;
86193   return jresult;
86194 }
86195
86196
86197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86198   void * jresult ;
86199   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86200   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86201
86202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86203   {
86204     try {
86205       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86206     } catch (std::out_of_range& e) {
86207       {
86208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86209       };
86210     } catch (std::exception& e) {
86211       {
86212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86213       };
86214     } catch (Dali::DaliException e) {
86215       {
86216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86217       };
86218     } catch (...) {
86219       {
86220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86221       };
86222     }
86223   }
86224
86225   jresult = (void *)result;
86226   return jresult;
86227 }
86228
86229
86230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86231   void * jresult ;
86232   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86233   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86234
86235   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86236   {
86237     try {
86238       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86239     } catch (std::out_of_range& e) {
86240       {
86241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86242       };
86243     } catch (std::exception& e) {
86244       {
86245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86246       };
86247     } catch (Dali::DaliException e) {
86248       {
86249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86250       };
86251     } catch (...) {
86252       {
86253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86254       };
86255     }
86256   }
86257
86258   jresult = (void *)result;
86259   return jresult;
86260 }
86261
86262
86263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86264   void * jresult ;
86265   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86266   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86267
86268   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86269   {
86270     try {
86271       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86272     } catch (std::out_of_range& e) {
86273       {
86274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86275       };
86276     } catch (std::exception& e) {
86277       {
86278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86279       };
86280     } catch (Dali::DaliException e) {
86281       {
86282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86283       };
86284     } catch (...) {
86285       {
86286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86287       };
86288     }
86289   }
86290
86291   jresult = (void *)result;
86292   return jresult;
86293 }
86294
86295
86296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86297   void * jresult ;
86298   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86299   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86300
86301   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86302   {
86303     try {
86304       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86305     } catch (std::out_of_range& e) {
86306       {
86307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86308       };
86309     } catch (std::exception& e) {
86310       {
86311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86312       };
86313     } catch (Dali::DaliException e) {
86314       {
86315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86316       };
86317     } catch (...) {
86318       {
86319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86320       };
86321     }
86322   }
86323
86324   jresult = (void *)result;
86325   return jresult;
86326 }
86327
86328
86329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86330   void * jresult ;
86331   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86332   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86333
86334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86335   {
86336     try {
86337       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86338     } catch (std::out_of_range& e) {
86339       {
86340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86341       };
86342     } catch (std::exception& e) {
86343       {
86344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86345       };
86346     } catch (Dali::DaliException e) {
86347       {
86348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86349       };
86350     } catch (...) {
86351       {
86352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86353       };
86354     }
86355   }
86356
86357   jresult = (void *)result;
86358   return jresult;
86359 }
86360
86361
86362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86363   void * jresult ;
86364   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86365   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86366
86367   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86368   {
86369     try {
86370       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86371     } catch (std::out_of_range& e) {
86372       {
86373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86374       };
86375     } catch (std::exception& e) {
86376       {
86377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86378       };
86379     } catch (Dali::DaliException e) {
86380       {
86381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86382       };
86383     } catch (...) {
86384       {
86385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86386       };
86387     }
86388   }
86389
86390   jresult = (void *)result;
86391   return jresult;
86392 }
86393
86394
86395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86396   void * jresult ;
86397   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86398   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86399
86400   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86401   {
86402     try {
86403       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86404     } catch (std::out_of_range& e) {
86405       {
86406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86407       };
86408     } catch (std::exception& e) {
86409       {
86410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86411       };
86412     } catch (Dali::DaliException e) {
86413       {
86414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86415       };
86416     } catch (...) {
86417       {
86418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86419       };
86420     }
86421   }
86422
86423   jresult = (void *)result;
86424   return jresult;
86425 }
86426
86427
86428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86429   void * jresult ;
86430   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86431   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86432
86433   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86434   {
86435     try {
86436       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86437     } catch (std::out_of_range& e) {
86438       {
86439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86440       };
86441     } catch (std::exception& e) {
86442       {
86443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86444       };
86445     } catch (Dali::DaliException e) {
86446       {
86447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86448       };
86449     } catch (...) {
86450       {
86451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86452       };
86453     }
86454   }
86455
86456   jresult = (void *)result;
86457   return jresult;
86458 }
86459
86460
86461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86462   void * jresult ;
86463   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86464   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86465
86466   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86467   {
86468     try {
86469       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86470     } catch (std::out_of_range& e) {
86471       {
86472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86473       };
86474     } catch (std::exception& e) {
86475       {
86476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86477       };
86478     } catch (Dali::DaliException e) {
86479       {
86480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86481       };
86482     } catch (...) {
86483       {
86484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86485       };
86486     }
86487   }
86488
86489   jresult = (void *)result;
86490   return jresult;
86491 }
86492
86493
86494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86495   void * jresult ;
86496   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86497   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86498
86499   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86500   {
86501     try {
86502       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86503     } catch (std::out_of_range& e) {
86504       {
86505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86506       };
86507     } catch (std::exception& e) {
86508       {
86509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86510       };
86511     } catch (Dali::DaliException e) {
86512       {
86513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86514       };
86515     } catch (...) {
86516       {
86517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86518       };
86519     }
86520   }
86521
86522   jresult = (void *)result;
86523   return jresult;
86524 }
86525
86526
86527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86528   void * jresult ;
86529   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86530   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86531
86532   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86533   {
86534     try {
86535       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86536     } catch (std::out_of_range& e) {
86537       {
86538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86539       };
86540     } catch (std::exception& e) {
86541       {
86542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86543       };
86544     } catch (Dali::DaliException e) {
86545       {
86546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86547       };
86548     } catch (...) {
86549       {
86550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86551       };
86552     }
86553   }
86554
86555   jresult = (void *)result;
86556   return jresult;
86557 }
86558
86559
86560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86561   void * jresult ;
86562   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86563   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86564
86565   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86566   {
86567     try {
86568       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86569     } catch (std::out_of_range& e) {
86570       {
86571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86572       };
86573     } catch (std::exception& e) {
86574       {
86575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86576       };
86577     } catch (Dali::DaliException e) {
86578       {
86579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86580       };
86581     } catch (...) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86584       };
86585     }
86586   }
86587
86588   jresult = (void *)result;
86589   return jresult;
86590 }
86591
86592
86593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86594   void * jresult ;
86595   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86596   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86597
86598   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86599   {
86600     try {
86601       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86602     } catch (std::out_of_range& e) {
86603       {
86604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86605       };
86606     } catch (std::exception& e) {
86607       {
86608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86609       };
86610     } catch (Dali::DaliException e) {
86611       {
86612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86613       };
86614     } catch (...) {
86615       {
86616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86617       };
86618     }
86619   }
86620
86621   jresult = (void *)result;
86622   return jresult;
86623 }
86624
86625
86626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86627   void * jresult ;
86628   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86629   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86630
86631   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86632   {
86633     try {
86634       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86635     } catch (std::out_of_range& e) {
86636       {
86637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86638       };
86639     } catch (std::exception& e) {
86640       {
86641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86642       };
86643     } catch (Dali::DaliException e) {
86644       {
86645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86646       };
86647     } catch (...) {
86648       {
86649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86650       };
86651     }
86652   }
86653
86654   jresult = (void *)result;
86655   return jresult;
86656 }
86657
86658
86659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86660   void * jresult ;
86661   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86662   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86663
86664   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86665   {
86666     try {
86667       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86668     } catch (std::out_of_range& e) {
86669       {
86670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86671       };
86672     } catch (std::exception& e) {
86673       {
86674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86675       };
86676     } catch (Dali::DaliException e) {
86677       {
86678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86679       };
86680     } catch (...) {
86681       {
86682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86683       };
86684     }
86685   }
86686
86687   jresult = (void *)result;
86688   return jresult;
86689 }
86690
86691
86692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86693   void * jresult ;
86694   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86695   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86696
86697   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86698   {
86699     try {
86700       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86701     } catch (std::out_of_range& e) {
86702       {
86703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86704       };
86705     } catch (std::exception& e) {
86706       {
86707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86708       };
86709     } catch (Dali::DaliException e) {
86710       {
86711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86712       };
86713     } catch (...) {
86714       {
86715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86716       };
86717     }
86718   }
86719
86720   jresult = (void *)result;
86721   return jresult;
86722 }
86723
86724
86725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86726   void * jresult ;
86727   Dali::Toolkit::StyleManager *result = 0 ;
86728
86729   {
86730     try {
86731       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86732     } catch (std::out_of_range& e) {
86733       {
86734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86735       };
86736     } catch (std::exception& e) {
86737       {
86738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86739       };
86740     } catch (Dali::DaliException e) {
86741       {
86742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86743       };
86744     } catch (...) {
86745       {
86746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86747       };
86748     }
86749   }
86750
86751   jresult = (void *)result;
86752   return jresult;
86753 }
86754
86755
86756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86757   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86758
86759   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86760   {
86761     try {
86762       delete arg1;
86763     } catch (std::out_of_range& e) {
86764       {
86765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86766       };
86767     } catch (std::exception& e) {
86768       {
86769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86770       };
86771     } catch (Dali::DaliException e) {
86772       {
86773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86774       };
86775     } catch (...) {
86776       {
86777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86778       };
86779     }
86780   }
86781
86782 }
86783
86784
86785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86786   void * jresult ;
86787   Dali::Toolkit::StyleManager result;
86788
86789   {
86790     try {
86791       result = Dali::Toolkit::StyleManager::Get();
86792     } catch (std::out_of_range& e) {
86793       {
86794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86795       };
86796     } catch (std::exception& e) {
86797       {
86798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86799       };
86800     } catch (Dali::DaliException e) {
86801       {
86802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86803       };
86804     } catch (...) {
86805       {
86806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86807       };
86808     }
86809   }
86810
86811   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86812   return jresult;
86813 }
86814
86815
86816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86817   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86818   std::string *arg2 = 0 ;
86819
86820   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86821   if (!jarg2) {
86822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86823     return ;
86824   }
86825   std::string arg2_str(jarg2);
86826   arg2 = &arg2_str;
86827   {
86828     try {
86829       (arg1)->ApplyTheme((std::string const &)*arg2);
86830     } catch (std::out_of_range& e) {
86831       {
86832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86833       };
86834     } catch (std::exception& e) {
86835       {
86836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86837       };
86838     } catch (Dali::DaliException e) {
86839       {
86840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86841       };
86842     } catch (...) {
86843       {
86844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86845       };
86846     }
86847   }
86848
86849
86850   //argout typemap for const std::string&
86851
86852 }
86853
86854
86855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86856   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86857
86858   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86859   {
86860     try {
86861       (arg1)->ApplyDefaultTheme();
86862     } catch (std::out_of_range& e) {
86863       {
86864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86865       };
86866     } catch (std::exception& e) {
86867       {
86868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86869       };
86870     } catch (Dali::DaliException e) {
86871       {
86872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86873       };
86874     } catch (...) {
86875       {
86876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86877       };
86878     }
86879   }
86880
86881 }
86882
86883
86884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86885   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86886   std::string *arg2 = 0 ;
86887   Dali::Property::Value *arg3 = 0 ;
86888
86889   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86890   if (!jarg2) {
86891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86892     return ;
86893   }
86894   std::string arg2_str(jarg2);
86895   arg2 = &arg2_str;
86896   arg3 = (Dali::Property::Value *)jarg3;
86897   if (!arg3) {
86898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86899     return ;
86900   }
86901   {
86902     try {
86903       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86904     } catch (std::out_of_range& e) {
86905       {
86906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86907       };
86908     } catch (std::exception& e) {
86909       {
86910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86911       };
86912     } catch (Dali::DaliException e) {
86913       {
86914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86915       };
86916     } catch (...) {
86917       {
86918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86919       };
86920     }
86921   }
86922
86923
86924   //argout typemap for const std::string&
86925
86926 }
86927
86928
86929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86930   unsigned int jresult ;
86931   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86932   std::string *arg2 = 0 ;
86933   Dali::Property::Value *arg3 = 0 ;
86934   bool result;
86935
86936   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86937   if (!jarg2) {
86938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86939     return 0;
86940   }
86941   std::string arg2_str(jarg2);
86942   arg2 = &arg2_str;
86943   arg3 = (Dali::Property::Value *)jarg3;
86944   if (!arg3) {
86945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86946     return 0;
86947   }
86948   {
86949     try {
86950       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86951     } catch (std::out_of_range& e) {
86952       {
86953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86954       };
86955     } catch (std::exception& e) {
86956       {
86957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86958       };
86959     } catch (Dali::DaliException e) {
86960       {
86961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86962       };
86963     } catch (...) {
86964       {
86965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86966       };
86967     }
86968   }
86969
86970   jresult = result;
86971
86972   //argout typemap for const std::string&
86973
86974   return jresult;
86975 }
86976
86977
86978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86979   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86980   Dali::Toolkit::Control arg2 ;
86981   std::string *arg3 = 0 ;
86982   std::string *arg4 = 0 ;
86983   Dali::Toolkit::Control *argp2 ;
86984
86985   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86986   argp2 = (Dali::Toolkit::Control *)jarg2;
86987   if (!argp2) {
86988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86989     return ;
86990   }
86991   arg2 = *argp2;
86992   if (!jarg3) {
86993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86994     return ;
86995   }
86996   std::string arg3_str(jarg3);
86997   arg3 = &arg3_str;
86998   if (!jarg4) {
86999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87000     return ;
87001   }
87002   std::string arg4_str(jarg4);
87003   arg4 = &arg4_str;
87004   {
87005     try {
87006       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87007     } catch (std::out_of_range& e) {
87008       {
87009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87010       };
87011     } catch (std::exception& e) {
87012       {
87013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87014       };
87015     } catch (Dali::DaliException e) {
87016       {
87017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87018       };
87019     } catch (...) {
87020       {
87021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87022       };
87023     }
87024   }
87025
87026
87027   //argout typemap for const std::string&
87028
87029
87030   //argout typemap for const std::string&
87031
87032 }
87033
87034
87035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87036   void * jresult ;
87037   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87038   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87039
87040   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87041   {
87042     try {
87043       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87044     } catch (std::out_of_range& e) {
87045       {
87046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87047       };
87048     } catch (std::exception& e) {
87049       {
87050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87051       };
87052     } catch (Dali::DaliException e) {
87053       {
87054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87055       };
87056     } catch (...) {
87057       {
87058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87059       };
87060     }
87061   }
87062
87063   jresult = (void *)result;
87064   return jresult;
87065 }
87066
87067
87068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87069   int jresult ;
87070   int result;
87071
87072   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87073   jresult = (int)result;
87074   return jresult;
87075 }
87076
87077
87078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87079   int jresult ;
87080   int result;
87081
87082   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87083   jresult = (int)result;
87084   return jresult;
87085 }
87086
87087
87088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87089   int jresult ;
87090   int result;
87091
87092   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87093   jresult = (int)result;
87094   return jresult;
87095 }
87096
87097
87098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87099   int jresult ;
87100   int result;
87101
87102   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87103   jresult = (int)result;
87104   return jresult;
87105 }
87106
87107
87108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87109   int jresult ;
87110   int result;
87111
87112   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87113   jresult = (int)result;
87114   return jresult;
87115 }
87116
87117
87118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87119   int jresult ;
87120   int result;
87121
87122   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87123   jresult = (int)result;
87124   return jresult;
87125 }
87126
87127
87128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87129   int jresult ;
87130   int result;
87131
87132   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87133   jresult = (int)result;
87134   return jresult;
87135 }
87136
87137
87138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87139   int jresult ;
87140   int result;
87141
87142   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87143   jresult = (int)result;
87144   return jresult;
87145 }
87146
87147
87148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87149   int jresult ;
87150   int result;
87151
87152   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87153   jresult = (int)result;
87154   return jresult;
87155 }
87156
87157
87158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87159   int jresult ;
87160   int result;
87161
87162   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87163   jresult = (int)result;
87164   return jresult;
87165 }
87166
87167
87168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87169   int jresult ;
87170   int result;
87171
87172   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87173   jresult = (int)result;
87174   return jresult;
87175 }
87176
87177
87178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87179   int jresult ;
87180   int result;
87181
87182   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87183   jresult = (int)result;
87184   return jresult;
87185 }
87186
87187
87188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87189   int jresult ;
87190   int result;
87191
87192   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87193   jresult = (int)result;
87194   return jresult;
87195 }
87196
87197
87198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87199   int jresult ;
87200   int result;
87201
87202   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87203   jresult = (int)result;
87204   return jresult;
87205 }
87206
87207
87208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87209   int jresult ;
87210   int result;
87211
87212   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87213   jresult = (int)result;
87214   return jresult;
87215 }
87216
87217
87218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87219   void * jresult ;
87220   Dali::Toolkit::Slider::Property *result = 0 ;
87221
87222   {
87223     try {
87224       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87225     } catch (std::out_of_range& e) {
87226       {
87227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87228       };
87229     } catch (std::exception& e) {
87230       {
87231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87232       };
87233     } catch (Dali::DaliException e) {
87234       {
87235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87236       };
87237     } catch (...) {
87238       {
87239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87240       };
87241     }
87242   }
87243
87244   jresult = (void *)result;
87245   return jresult;
87246 }
87247
87248
87249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87250   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87251
87252   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87253   {
87254     try {
87255       delete arg1;
87256     } catch (std::out_of_range& e) {
87257       {
87258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87259       };
87260     } catch (std::exception& e) {
87261       {
87262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87263       };
87264     } catch (Dali::DaliException e) {
87265       {
87266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87267       };
87268     } catch (...) {
87269       {
87270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87271       };
87272     }
87273   }
87274
87275 }
87276
87277
87278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87279   void * jresult ;
87280   Dali::Toolkit::Slider result;
87281
87282   {
87283     try {
87284       result = Dali::Toolkit::Slider::New();
87285     } catch (std::out_of_range& e) {
87286       {
87287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87288       };
87289     } catch (std::exception& e) {
87290       {
87291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87292       };
87293     } catch (Dali::DaliException e) {
87294       {
87295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87296       };
87297     } catch (...) {
87298       {
87299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87300       };
87301     }
87302   }
87303
87304   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87305   return jresult;
87306 }
87307
87308
87309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87310   void * jresult ;
87311   Dali::Toolkit::Slider *result = 0 ;
87312
87313   {
87314     try {
87315       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87316     } catch (std::out_of_range& e) {
87317       {
87318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87319       };
87320     } catch (std::exception& e) {
87321       {
87322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87323       };
87324     } catch (Dali::DaliException e) {
87325       {
87326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87327       };
87328     } catch (...) {
87329       {
87330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87331       };
87332     }
87333   }
87334
87335   jresult = (void *)result;
87336   return jresult;
87337 }
87338
87339
87340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87341   void * jresult ;
87342   Dali::Toolkit::Slider *arg1 = 0 ;
87343   Dali::Toolkit::Slider *result = 0 ;
87344
87345   arg1 = (Dali::Toolkit::Slider *)jarg1;
87346   if (!arg1) {
87347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87348     return 0;
87349   }
87350   {
87351     try {
87352       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87353     } catch (std::out_of_range& e) {
87354       {
87355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87356       };
87357     } catch (std::exception& e) {
87358       {
87359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87360       };
87361     } catch (Dali::DaliException e) {
87362       {
87363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87364       };
87365     } catch (...) {
87366       {
87367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87368       };
87369     }
87370   }
87371
87372   jresult = (void *)result;
87373   return jresult;
87374 }
87375
87376
87377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87378   void * jresult ;
87379   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87380   Dali::Toolkit::Slider *arg2 = 0 ;
87381   Dali::Toolkit::Slider *result = 0 ;
87382
87383   arg1 = (Dali::Toolkit::Slider *)jarg1;
87384   arg2 = (Dali::Toolkit::Slider *)jarg2;
87385   if (!arg2) {
87386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87387     return 0;
87388   }
87389   {
87390     try {
87391       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87392     } catch (std::out_of_range& e) {
87393       {
87394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87395       };
87396     } catch (std::exception& e) {
87397       {
87398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87399       };
87400     } catch (Dali::DaliException e) {
87401       {
87402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87403       };
87404     } catch (...) {
87405       {
87406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87407       };
87408     }
87409   }
87410
87411   jresult = (void *)result;
87412   return jresult;
87413 }
87414
87415
87416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87417   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87418
87419   arg1 = (Dali::Toolkit::Slider *)jarg1;
87420   {
87421     try {
87422       delete arg1;
87423     } catch (std::out_of_range& e) {
87424       {
87425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87426       };
87427     } catch (std::exception& e) {
87428       {
87429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87430       };
87431     } catch (Dali::DaliException e) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87434       };
87435     } catch (...) {
87436       {
87437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87438       };
87439     }
87440   }
87441
87442 }
87443
87444
87445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87446   void * jresult ;
87447   Dali::BaseHandle arg1 ;
87448   Dali::BaseHandle *argp1 ;
87449   Dali::Toolkit::Slider result;
87450
87451   argp1 = (Dali::BaseHandle *)jarg1;
87452   if (!argp1) {
87453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87454     return 0;
87455   }
87456   arg1 = *argp1;
87457   {
87458     try {
87459       result = Dali::Toolkit::Slider::DownCast(arg1);
87460     } catch (std::out_of_range& e) {
87461       {
87462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87463       };
87464     } catch (std::exception& e) {
87465       {
87466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87467       };
87468     } catch (Dali::DaliException e) {
87469       {
87470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87471       };
87472     } catch (...) {
87473       {
87474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87475       };
87476     }
87477   }
87478
87479   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87480   return jresult;
87481 }
87482
87483
87484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87485   void * jresult ;
87486   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87487   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87488
87489   arg1 = (Dali::Toolkit::Slider *)jarg1;
87490   {
87491     try {
87492       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87493     } catch (std::out_of_range& e) {
87494       {
87495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87496       };
87497     } catch (std::exception& e) {
87498       {
87499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87500       };
87501     } catch (Dali::DaliException e) {
87502       {
87503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87504       };
87505     } catch (...) {
87506       {
87507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87508       };
87509     }
87510   }
87511
87512   jresult = (void *)result;
87513   return jresult;
87514 }
87515
87516
87517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87518   void * jresult ;
87519   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87520   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87521
87522   arg1 = (Dali::Toolkit::Slider *)jarg1;
87523   {
87524     try {
87525       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87526     } catch (std::out_of_range& e) {
87527       {
87528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87529       };
87530     } catch (std::exception& e) {
87531       {
87532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87533       };
87534     } catch (Dali::DaliException e) {
87535       {
87536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87537       };
87538     } catch (...) {
87539       {
87540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87541       };
87542     }
87543   }
87544
87545   jresult = (void *)result;
87546   return jresult;
87547 }
87548
87549
87550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87551   void * jresult ;
87552   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87553   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87554
87555   arg1 = (Dali::Toolkit::Slider *)jarg1;
87556   {
87557     try {
87558       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87559     } catch (std::out_of_range& e) {
87560       {
87561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87562       };
87563     } catch (std::exception& e) {
87564       {
87565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87566       };
87567     } catch (Dali::DaliException e) {
87568       {
87569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87570       };
87571     } catch (...) {
87572       {
87573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87574       };
87575     }
87576   }
87577
87578   jresult = (void *)result;
87579   return jresult;
87580 }
87581
87582
87583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87584   int jresult ;
87585   int result;
87586
87587   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87588   jresult = (int)result;
87589   return jresult;
87590 }
87591
87592
87593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87594   int jresult ;
87595   int result;
87596
87597   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87598   jresult = (int)result;
87599   return jresult;
87600 }
87601
87602
87603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87604   int jresult ;
87605   int result;
87606
87607   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87608   jresult = (int)result;
87609   return jresult;
87610 }
87611
87612
87613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87614   int jresult ;
87615   int result;
87616
87617   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87618   jresult = (int)result;
87619   return jresult;
87620 }
87621
87622
87623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87624   int result;
87625
87626   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87627
87628   return result;
87629 }
87630
87631
87632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87633   void * jresult ;
87634   Dali::Toolkit::VideoView::Property *result = 0 ;
87635
87636   {
87637     try {
87638       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87639     } catch (std::out_of_range& e) {
87640       {
87641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87642       };
87643     } catch (std::exception& e) {
87644       {
87645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87646       };
87647     } catch (Dali::DaliException e) {
87648       {
87649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87650       };
87651     } catch (...) {
87652       {
87653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87654       };
87655     }
87656   }
87657
87658   jresult = (void *)result;
87659   return jresult;
87660 }
87661
87662
87663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87664   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87665
87666   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87667   {
87668     try {
87669       delete arg1;
87670     } catch (std::out_of_range& e) {
87671       {
87672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87673       };
87674     } catch (std::exception& e) {
87675       {
87676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87677       };
87678     } catch (Dali::DaliException e) {
87679       {
87680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87681       };
87682     } catch (...) {
87683       {
87684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87685       };
87686     }
87687   }
87688
87689 }
87690
87691
87692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87693   void * jresult ;
87694   Dali::Toolkit::VideoView result;
87695
87696   {
87697     try {
87698       result = Dali::Toolkit::VideoView::New();
87699     } catch (std::out_of_range& e) {
87700       {
87701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87702       };
87703     } catch (std::exception& e) {
87704       {
87705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87706       };
87707     } catch (Dali::DaliException e) {
87708       {
87709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87710       };
87711     } catch (...) {
87712       {
87713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87714       };
87715     }
87716   }
87717
87718   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87719   return jresult;
87720 }
87721
87722
87723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87724   void * jresult ;
87725   std::string *arg1 = 0 ;
87726   Dali::Toolkit::VideoView result;
87727
87728   if (!jarg1) {
87729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87730     return 0;
87731   }
87732   std::string arg1_str(jarg1);
87733   arg1 = &arg1_str;
87734   {
87735     try {
87736       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87737     } catch (std::out_of_range& e) {
87738       {
87739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87740       };
87741     } catch (std::exception& e) {
87742       {
87743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87744       };
87745     } catch (Dali::DaliException e) {
87746       {
87747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87748       };
87749     } catch (...) {
87750       {
87751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87752       };
87753     }
87754   }
87755
87756   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87757
87758   //argout typemap for const std::string&
87759
87760   return jresult;
87761 }
87762
87763
87764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87765   void * jresult ;
87766   Dali::Toolkit::VideoView *result = 0 ;
87767
87768   {
87769     try {
87770       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87771     } catch (std::out_of_range& e) {
87772       {
87773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87774       };
87775     } catch (std::exception& e) {
87776       {
87777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87778       };
87779     } catch (Dali::DaliException e) {
87780       {
87781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87782       };
87783     } catch (...) {
87784       {
87785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87786       };
87787     }
87788   }
87789
87790   jresult = (void *)result;
87791   return jresult;
87792 }
87793
87794
87795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87796   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87797
87798   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87799   {
87800     try {
87801       delete arg1;
87802     } catch (std::out_of_range& e) {
87803       {
87804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87805       };
87806     } catch (std::exception& e) {
87807       {
87808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87809       };
87810     } catch (Dali::DaliException e) {
87811       {
87812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87813       };
87814     } catch (...) {
87815       {
87816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87817       };
87818     }
87819   }
87820
87821 }
87822
87823
87824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87825   void * jresult ;
87826   Dali::Toolkit::VideoView *arg1 = 0 ;
87827   Dali::Toolkit::VideoView *result = 0 ;
87828
87829   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87830   if (!arg1) {
87831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87832     return 0;
87833   }
87834   {
87835     try {
87836       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87837     } catch (std::out_of_range& e) {
87838       {
87839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87840       };
87841     } catch (std::exception& e) {
87842       {
87843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87844       };
87845     } catch (Dali::DaliException e) {
87846       {
87847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87848       };
87849     } catch (...) {
87850       {
87851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87852       };
87853     }
87854   }
87855
87856   jresult = (void *)result;
87857   return jresult;
87858 }
87859
87860
87861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87862   void * jresult ;
87863   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87864   Dali::Toolkit::VideoView *arg2 = 0 ;
87865   Dali::Toolkit::VideoView *result = 0 ;
87866
87867   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87868   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87869   if (!arg2) {
87870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87871     return 0;
87872   }
87873   {
87874     try {
87875       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87876     } catch (std::out_of_range& e) {
87877       {
87878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87879       };
87880     } catch (std::exception& e) {
87881       {
87882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87883       };
87884     } catch (Dali::DaliException e) {
87885       {
87886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87887       };
87888     } catch (...) {
87889       {
87890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87891       };
87892     }
87893   }
87894
87895   jresult = (void *)result;
87896   return jresult;
87897 }
87898
87899
87900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87901   void * jresult ;
87902   Dali::BaseHandle arg1 ;
87903   Dali::BaseHandle *argp1 ;
87904   Dali::Toolkit::VideoView result;
87905
87906   argp1 = (Dali::BaseHandle *)jarg1;
87907   if (!argp1) {
87908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87909     return 0;
87910   }
87911   arg1 = *argp1;
87912   {
87913     try {
87914       result = Dali::Toolkit::VideoView::DownCast(arg1);
87915     } catch (std::out_of_range& e) {
87916       {
87917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87918       };
87919     } catch (std::exception& e) {
87920       {
87921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87922       };
87923     } catch (Dali::DaliException e) {
87924       {
87925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87926       };
87927     } catch (...) {
87928       {
87929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87930       };
87931     }
87932   }
87933
87934   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87935   return jresult;
87936 }
87937
87938
87939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87940   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87941
87942   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87943   {
87944     try {
87945       (arg1)->Play();
87946     } catch (std::out_of_range& e) {
87947       {
87948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87949       };
87950     } catch (std::exception& e) {
87951       {
87952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87953       };
87954     } catch (Dali::DaliException e) {
87955       {
87956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87957       };
87958     } catch (...) {
87959       {
87960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87961       };
87962     }
87963   }
87964
87965 }
87966
87967
87968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87969   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87970
87971   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87972   {
87973     try {
87974       (arg1)->Pause();
87975     } catch (std::out_of_range& e) {
87976       {
87977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87978       };
87979     } catch (std::exception& e) {
87980       {
87981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87982       };
87983     } catch (Dali::DaliException e) {
87984       {
87985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87986       };
87987     } catch (...) {
87988       {
87989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87990       };
87991     }
87992   }
87993
87994 }
87995
87996
87997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87998   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87999
88000   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88001   {
88002     try {
88003       (arg1)->Stop();
88004     } catch (std::out_of_range& e) {
88005       {
88006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88007       };
88008     } catch (std::exception& e) {
88009       {
88010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88011       };
88012     } catch (Dali::DaliException e) {
88013       {
88014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88015       };
88016     } catch (...) {
88017       {
88018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88019       };
88020     }
88021   }
88022
88023 }
88024
88025
88026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88027   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88028   int arg2 ;
88029
88030   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88031   arg2 = (int)jarg2;
88032   {
88033     try {
88034       (arg1)->Forward(arg2);
88035     } catch (std::out_of_range& e) {
88036       {
88037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88038       };
88039     } catch (std::exception& e) {
88040       {
88041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88042       };
88043     } catch (Dali::DaliException e) {
88044       {
88045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88046       };
88047     } catch (...) {
88048       {
88049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88050       };
88051     }
88052   }
88053
88054 }
88055
88056
88057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88058   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88059   int arg2 ;
88060
88061   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88062   arg2 = (int)jarg2;
88063   {
88064     try {
88065       (arg1)->Backward(arg2);
88066     } catch (std::out_of_range& e) {
88067       {
88068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88069       };
88070     } catch (std::exception& e) {
88071       {
88072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88073       };
88074     } catch (Dali::DaliException e) {
88075       {
88076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88077       };
88078     } catch (...) {
88079       {
88080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88081       };
88082     }
88083   }
88084
88085 }
88086
88087
88088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88089   void * jresult ;
88090   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88091   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88092
88093   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88094   {
88095     try {
88096       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88097     } catch (std::out_of_range& e) {
88098       {
88099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88100       };
88101     } catch (std::exception& e) {
88102       {
88103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88104       };
88105     } catch (Dali::DaliException e) {
88106       {
88107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88108       };
88109     } catch (...) {
88110       {
88111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88112       };
88113     }
88114   }
88115
88116   jresult = (void *)result;
88117   return jresult;
88118 }
88119
88120
88121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88122   int jresult ;
88123   int result;
88124
88125   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88126   jresult = (int)result;
88127   return jresult;
88128 }
88129
88130
88131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88132   int jresult ;
88133   int result;
88134
88135   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88136   jresult = (int)result;
88137   return jresult;
88138 }
88139
88140
88141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88142   int jresult ;
88143   int result;
88144
88145   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88146   jresult = (int)result;
88147   return jresult;
88148 }
88149
88150
88151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88152   int jresult ;
88153   int result;
88154
88155   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88156   jresult = (int)result;
88157   return jresult;
88158 }
88159
88160
88161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88162   int jresult ;
88163   int result;
88164
88165   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88166   jresult = (int)result;
88167   return jresult;
88168 }
88169
88170
88171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88172   int jresult ;
88173   int result;
88174
88175   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88176   jresult = (int)result;
88177   return jresult;
88178 }
88179
88180
88181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88182   int jresult ;
88183   int result;
88184
88185   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88186   jresult = (int)result;
88187   return jresult;
88188 }
88189
88190
88191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88192   int jresult ;
88193   int result;
88194
88195   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88196   jresult = (int)result;
88197   return jresult;
88198 }
88199
88200
88201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88202   int jresult ;
88203   int result;
88204
88205   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88206   jresult = (int)result;
88207   return jresult;
88208 }
88209
88210
88211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88212   int jresult ;
88213   int result;
88214
88215   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88216   jresult = (int)result;
88217   return jresult;
88218 }
88219
88220
88221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88222   int jresult ;
88223   int result;
88224
88225   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88226   jresult = (int)result;
88227   return jresult;
88228 }
88229
88230
88231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88232   int jresult ;
88233   int result;
88234
88235   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88236   jresult = (int)result;
88237   return jresult;
88238 }
88239
88240
88241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88242   int jresult ;
88243   int result;
88244
88245   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88246   jresult = (int)result;
88247   return jresult;
88248 }
88249
88250
88251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88252   int jresult ;
88253   int result;
88254
88255   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88256   jresult = (int)result;
88257   return jresult;
88258 }
88259
88260
88261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88262   int jresult ;
88263   int result;
88264
88265   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88266   jresult = (int)result;
88267   return jresult;
88268 }
88269
88270
88271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88272   int jresult ;
88273   int result;
88274
88275   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88276   jresult = (int)result;
88277   return jresult;
88278 }
88279
88280
88281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88282   int jresult ;
88283   int result;
88284
88285   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88286   jresult = (int)result;
88287   return jresult;
88288 }
88289
88290
88291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88292   int jresult ;
88293   int result;
88294
88295   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88296   jresult = (int)result;
88297   return jresult;
88298 }
88299
88300
88301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88302   int jresult ;
88303   int result;
88304
88305   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88306   jresult = (int)result;
88307   return jresult;
88308 }
88309
88310
88311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88312   int jresult ;
88313   int result;
88314
88315   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88316   jresult = (int)result;
88317   return jresult;
88318 }
88319
88320
88321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88322   int jresult ;
88323   int result;
88324
88325   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88326   jresult = (int)result;
88327   return jresult;
88328 }
88329
88330
88331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88332   void * jresult ;
88333   Dali::Toolkit::Popup::Property *result = 0 ;
88334
88335   {
88336     try {
88337       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88338     } catch (std::out_of_range& e) {
88339       {
88340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88341       };
88342     } catch (std::exception& e) {
88343       {
88344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88345       };
88346     } catch (Dali::DaliException e) {
88347       {
88348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88349       };
88350     } catch (...) {
88351       {
88352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88353       };
88354     }
88355   }
88356
88357   jresult = (void *)result;
88358   return jresult;
88359 }
88360
88361
88362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88363   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88364
88365   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88366   {
88367     try {
88368       delete arg1;
88369     } catch (std::out_of_range& e) {
88370       {
88371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88372       };
88373     } catch (std::exception& e) {
88374       {
88375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88376       };
88377     } catch (Dali::DaliException e) {
88378       {
88379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88380       };
88381     } catch (...) {
88382       {
88383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88384       };
88385     }
88386   }
88387
88388 }
88389
88390
88391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88392   void * jresult ;
88393   Dali::Toolkit::Popup *result = 0 ;
88394
88395   {
88396     try {
88397       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88398     } catch (std::out_of_range& e) {
88399       {
88400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88401       };
88402     } catch (std::exception& e) {
88403       {
88404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88405       };
88406     } catch (Dali::DaliException e) {
88407       {
88408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88409       };
88410     } catch (...) {
88411       {
88412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88413       };
88414     }
88415   }
88416
88417   jresult = (void *)result;
88418   return jresult;
88419 }
88420
88421
88422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88423   void * jresult ;
88424   Dali::Toolkit::Popup result;
88425
88426   {
88427     try {
88428       result = Dali::Toolkit::Popup::New();
88429     } catch (std::out_of_range& e) {
88430       {
88431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88432       };
88433     } catch (std::exception& e) {
88434       {
88435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88436       };
88437     } catch (Dali::DaliException e) {
88438       {
88439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88440       };
88441     } catch (...) {
88442       {
88443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88444       };
88445     }
88446   }
88447
88448   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88449   return jresult;
88450 }
88451
88452
88453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88454   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88455
88456   arg1 = (Dali::Toolkit::Popup *)jarg1;
88457   {
88458     try {
88459       delete arg1;
88460     } catch (std::out_of_range& e) {
88461       {
88462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88463       };
88464     } catch (std::exception& e) {
88465       {
88466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88467       };
88468     } catch (Dali::DaliException e) {
88469       {
88470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88471       };
88472     } catch (...) {
88473       {
88474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88475       };
88476     }
88477   }
88478
88479 }
88480
88481
88482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88483   void * jresult ;
88484   Dali::Toolkit::Popup *arg1 = 0 ;
88485   Dali::Toolkit::Popup *result = 0 ;
88486
88487   arg1 = (Dali::Toolkit::Popup *)jarg1;
88488   if (!arg1) {
88489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88490     return 0;
88491   }
88492   {
88493     try {
88494       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88495     } catch (std::out_of_range& e) {
88496       {
88497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88498       };
88499     } catch (std::exception& e) {
88500       {
88501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88502       };
88503     } catch (Dali::DaliException e) {
88504       {
88505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88506       };
88507     } catch (...) {
88508       {
88509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88510       };
88511     }
88512   }
88513
88514   jresult = (void *)result;
88515   return jresult;
88516 }
88517
88518
88519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88520   void * jresult ;
88521   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88522   Dali::Toolkit::Popup *arg2 = 0 ;
88523   Dali::Toolkit::Popup *result = 0 ;
88524
88525   arg1 = (Dali::Toolkit::Popup *)jarg1;
88526   arg2 = (Dali::Toolkit::Popup *)jarg2;
88527   if (!arg2) {
88528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88529     return 0;
88530   }
88531   {
88532     try {
88533       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88534     } catch (std::out_of_range& e) {
88535       {
88536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88537       };
88538     } catch (std::exception& e) {
88539       {
88540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88541       };
88542     } catch (Dali::DaliException e) {
88543       {
88544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88545       };
88546     } catch (...) {
88547       {
88548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88549       };
88550     }
88551   }
88552
88553   jresult = (void *)result;
88554   return jresult;
88555 }
88556
88557
88558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88559   void * jresult ;
88560   Dali::BaseHandle arg1 ;
88561   Dali::BaseHandle *argp1 ;
88562   Dali::Toolkit::Popup result;
88563
88564   argp1 = (Dali::BaseHandle *)jarg1;
88565   if (!argp1) {
88566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88567     return 0;
88568   }
88569   arg1 = *argp1;
88570   {
88571     try {
88572       result = Dali::Toolkit::Popup::DownCast(arg1);
88573     } catch (std::out_of_range& e) {
88574       {
88575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88576       };
88577     } catch (std::exception& e) {
88578       {
88579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88580       };
88581     } catch (Dali::DaliException e) {
88582       {
88583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88584       };
88585     } catch (...) {
88586       {
88587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88588       };
88589     }
88590   }
88591
88592   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88593   return jresult;
88594 }
88595
88596
88597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88598   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88599   Dali::Actor arg2 ;
88600   Dali::Actor *argp2 ;
88601
88602   arg1 = (Dali::Toolkit::Popup *)jarg1;
88603   argp2 = (Dali::Actor *)jarg2;
88604   if (!argp2) {
88605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88606     return ;
88607   }
88608   arg2 = *argp2;
88609   {
88610     try {
88611       (arg1)->SetTitle(arg2);
88612     } catch (std::out_of_range& e) {
88613       {
88614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88615       };
88616     } catch (std::exception& e) {
88617       {
88618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88619       };
88620     } catch (Dali::DaliException e) {
88621       {
88622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88623       };
88624     } catch (...) {
88625       {
88626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88627       };
88628     }
88629   }
88630
88631 }
88632
88633
88634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88635   void * jresult ;
88636   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88637   Dali::Actor result;
88638
88639   arg1 = (Dali::Toolkit::Popup *)jarg1;
88640   {
88641     try {
88642       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88643     } catch (std::out_of_range& e) {
88644       {
88645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88646       };
88647     } catch (std::exception& e) {
88648       {
88649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88650       };
88651     } catch (Dali::DaliException e) {
88652       {
88653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88654       };
88655     } catch (...) {
88656       {
88657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88658       };
88659     }
88660   }
88661
88662   jresult = new Dali::Actor((const Dali::Actor &)result);
88663   return jresult;
88664 }
88665
88666
88667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88668   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88669   Dali::Actor arg2 ;
88670   Dali::Actor *argp2 ;
88671
88672   arg1 = (Dali::Toolkit::Popup *)jarg1;
88673   argp2 = (Dali::Actor *)jarg2;
88674   if (!argp2) {
88675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88676     return ;
88677   }
88678   arg2 = *argp2;
88679   {
88680     try {
88681       (arg1)->SetContent(arg2);
88682     } catch (std::out_of_range& e) {
88683       {
88684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88685       };
88686     } catch (std::exception& e) {
88687       {
88688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88689       };
88690     } catch (Dali::DaliException e) {
88691       {
88692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88693       };
88694     } catch (...) {
88695       {
88696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88697       };
88698     }
88699   }
88700
88701 }
88702
88703
88704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88705   void * jresult ;
88706   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88707   Dali::Actor result;
88708
88709   arg1 = (Dali::Toolkit::Popup *)jarg1;
88710   {
88711     try {
88712       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88713     } catch (std::out_of_range& e) {
88714       {
88715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88716       };
88717     } catch (std::exception& e) {
88718       {
88719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88720       };
88721     } catch (Dali::DaliException e) {
88722       {
88723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88724       };
88725     } catch (...) {
88726       {
88727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88728       };
88729     }
88730   }
88731
88732   jresult = new Dali::Actor((const Dali::Actor &)result);
88733   return jresult;
88734 }
88735
88736
88737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88738   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88739   Dali::Actor arg2 ;
88740   Dali::Actor *argp2 ;
88741
88742   arg1 = (Dali::Toolkit::Popup *)jarg1;
88743   argp2 = (Dali::Actor *)jarg2;
88744   if (!argp2) {
88745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88746     return ;
88747   }
88748   arg2 = *argp2;
88749   {
88750     try {
88751       (arg1)->SetFooter(arg2);
88752     } catch (std::out_of_range& e) {
88753       {
88754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88755       };
88756     } catch (std::exception& e) {
88757       {
88758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88759       };
88760     } catch (Dali::DaliException e) {
88761       {
88762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88763       };
88764     } catch (...) {
88765       {
88766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88767       };
88768     }
88769   }
88770
88771 }
88772
88773
88774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88775   void * jresult ;
88776   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88777   Dali::Actor result;
88778
88779   arg1 = (Dali::Toolkit::Popup *)jarg1;
88780   {
88781     try {
88782       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88783     } catch (std::out_of_range& e) {
88784       {
88785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88786       };
88787     } catch (std::exception& e) {
88788       {
88789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88790       };
88791     } catch (Dali::DaliException e) {
88792       {
88793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88794       };
88795     } catch (...) {
88796       {
88797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88798       };
88799     }
88800   }
88801
88802   jresult = new Dali::Actor((const Dali::Actor &)result);
88803   return jresult;
88804 }
88805
88806
88807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88808   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88809   Dali::Toolkit::Popup::DisplayState arg2 ;
88810
88811   arg1 = (Dali::Toolkit::Popup *)jarg1;
88812   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88813   {
88814     try {
88815       (arg1)->SetDisplayState(arg2);
88816     } catch (std::out_of_range& e) {
88817       {
88818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88819       };
88820     } catch (std::exception& e) {
88821       {
88822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88823       };
88824     } catch (Dali::DaliException e) {
88825       {
88826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88827       };
88828     } catch (...) {
88829       {
88830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88831       };
88832     }
88833   }
88834
88835 }
88836
88837
88838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88839   int jresult ;
88840   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88841   Dali::Toolkit::Popup::DisplayState result;
88842
88843   arg1 = (Dali::Toolkit::Popup *)jarg1;
88844   {
88845     try {
88846       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88847     } catch (std::out_of_range& e) {
88848       {
88849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88850       };
88851     } catch (std::exception& e) {
88852       {
88853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88854       };
88855     } catch (Dali::DaliException e) {
88856       {
88857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88858       };
88859     } catch (...) {
88860       {
88861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88862       };
88863     }
88864   }
88865
88866   jresult = (int)result;
88867   return jresult;
88868 }
88869
88870
88871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88872   void * jresult ;
88873   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88874   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88875
88876   arg1 = (Dali::Toolkit::Popup *)jarg1;
88877   {
88878     try {
88879       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88880     } catch (std::out_of_range& e) {
88881       {
88882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88883       };
88884     } catch (std::exception& e) {
88885       {
88886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88887       };
88888     } catch (Dali::DaliException e) {
88889       {
88890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88891       };
88892     } catch (...) {
88893       {
88894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88895       };
88896     }
88897   }
88898
88899   jresult = (void *)result;
88900   return jresult;
88901 }
88902
88903
88904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88905   void * jresult ;
88906   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88907   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88908
88909   arg1 = (Dali::Toolkit::Popup *)jarg1;
88910   {
88911     try {
88912       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88913     } catch (std::out_of_range& e) {
88914       {
88915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88916       };
88917     } catch (std::exception& e) {
88918       {
88919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88920       };
88921     } catch (Dali::DaliException e) {
88922       {
88923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88924       };
88925     } catch (...) {
88926       {
88927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88928       };
88929     }
88930   }
88931
88932   jresult = (void *)result;
88933   return jresult;
88934 }
88935
88936
88937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88938   void * jresult ;
88939   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88940   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88941
88942   arg1 = (Dali::Toolkit::Popup *)jarg1;
88943   {
88944     try {
88945       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88946     } catch (std::out_of_range& e) {
88947       {
88948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88949       };
88950     } catch (std::exception& e) {
88951       {
88952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88953       };
88954     } catch (Dali::DaliException e) {
88955       {
88956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88957       };
88958     } catch (...) {
88959       {
88960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88961       };
88962     }
88963   }
88964
88965   jresult = (void *)result;
88966   return jresult;
88967 }
88968
88969
88970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88971   void * jresult ;
88972   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88973   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88974
88975   arg1 = (Dali::Toolkit::Popup *)jarg1;
88976   {
88977     try {
88978       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88979     } catch (std::out_of_range& e) {
88980       {
88981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88982       };
88983     } catch (std::exception& e) {
88984       {
88985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88986       };
88987     } catch (Dali::DaliException e) {
88988       {
88989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88990       };
88991     } catch (...) {
88992       {
88993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88994       };
88995     }
88996   }
88997
88998   jresult = (void *)result;
88999   return jresult;
89000 }
89001
89002
89003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89004   void * jresult ;
89005   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89006   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89007
89008   arg1 = (Dali::Toolkit::Popup *)jarg1;
89009   {
89010     try {
89011       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89012     } catch (std::out_of_range& e) {
89013       {
89014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89015       };
89016     } catch (std::exception& e) {
89017       {
89018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89019       };
89020     } catch (Dali::DaliException e) {
89021       {
89022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89023       };
89024     } catch (...) {
89025       {
89026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89027       };
89028     }
89029   }
89030
89031   jresult = (void *)result;
89032   return jresult;
89033 }
89034
89035
89036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89037   int jresult ;
89038   int result;
89039
89040   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89041   jresult = (int)result;
89042   return jresult;
89043 }
89044
89045
89046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89047   int jresult ;
89048   int result;
89049
89050   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89051   jresult = (int)result;
89052   return jresult;
89053 }
89054
89055
89056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89057   int jresult ;
89058   int result;
89059
89060   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89061   jresult = (int)result;
89062   return jresult;
89063 }
89064
89065
89066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89067   int jresult ;
89068   int result;
89069
89070   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89071   jresult = (int)result;
89072   return jresult;
89073 }
89074
89075
89076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89077   int jresult ;
89078   int result;
89079
89080   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89081   jresult = (int)result;
89082   return jresult;
89083 }
89084
89085
89086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89087   int jresult ;
89088   int result;
89089
89090   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89091   jresult = (int)result;
89092   return jresult;
89093 }
89094
89095
89096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89097   int jresult ;
89098   int result;
89099
89100   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89101   jresult = (int)result;
89102   return jresult;
89103 }
89104
89105
89106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89107   int jresult ;
89108   int result;
89109
89110   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89111   jresult = (int)result;
89112   return jresult;
89113 }
89114
89115
89116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89117   int jresult ;
89118   int result;
89119
89120   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89121   jresult = (int)result;
89122   return jresult;
89123 }
89124
89125
89126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89127   void * jresult ;
89128   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89129
89130   {
89131     try {
89132       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89133     } catch (std::out_of_range& e) {
89134       {
89135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89136       };
89137     } catch (std::exception& e) {
89138       {
89139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89140       };
89141     } catch (Dali::DaliException e) {
89142       {
89143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89144       };
89145     } catch (...) {
89146       {
89147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89148       };
89149     }
89150   }
89151
89152   jresult = (void *)result;
89153   return jresult;
89154 }
89155
89156
89157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89158   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89159
89160   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89161   {
89162     try {
89163       delete arg1;
89164     } catch (std::out_of_range& e) {
89165       {
89166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89167       };
89168     } catch (std::exception& e) {
89169       {
89170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89171       };
89172     } catch (Dali::DaliException e) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89175       };
89176     } catch (...) {
89177       {
89178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89179       };
89180     }
89181   }
89182
89183 }
89184
89185
89186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89187   void * jresult ;
89188   Dali::Toolkit::ProgressBar result;
89189
89190   {
89191     try {
89192       result = Dali::Toolkit::ProgressBar::New();
89193     } catch (std::out_of_range& e) {
89194       {
89195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89196       };
89197     } catch (std::exception& e) {
89198       {
89199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89200       };
89201     } catch (Dali::DaliException e) {
89202       {
89203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89204       };
89205     } catch (...) {
89206       {
89207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89208       };
89209     }
89210   }
89211
89212   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89213   return jresult;
89214 }
89215
89216
89217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89218   void * jresult ;
89219   Dali::Toolkit::ProgressBar *result = 0 ;
89220
89221   {
89222     try {
89223       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89224     } catch (std::out_of_range& e) {
89225       {
89226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89227       };
89228     } catch (std::exception& e) {
89229       {
89230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89231       };
89232     } catch (Dali::DaliException e) {
89233       {
89234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89235       };
89236     } catch (...) {
89237       {
89238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89239       };
89240     }
89241   }
89242
89243   jresult = (void *)result;
89244   return jresult;
89245 }
89246
89247
89248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89249   void * jresult ;
89250   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89251   Dali::Toolkit::ProgressBar *result = 0 ;
89252
89253   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89254   if (!arg1) {
89255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89256     return 0;
89257   }
89258   {
89259     try {
89260       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89261     } catch (std::out_of_range& e) {
89262       {
89263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89264       };
89265     } catch (std::exception& e) {
89266       {
89267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89268       };
89269     } catch (Dali::DaliException e) {
89270       {
89271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89272       };
89273     } catch (...) {
89274       {
89275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89276       };
89277     }
89278   }
89279
89280   jresult = (void *)result;
89281   return jresult;
89282 }
89283
89284
89285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89286   void * jresult ;
89287   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89288   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89289   Dali::Toolkit::ProgressBar *result = 0 ;
89290
89291   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89292   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89293   if (!arg2) {
89294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89295     return 0;
89296   }
89297   {
89298     try {
89299       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89300     } catch (std::out_of_range& e) {
89301       {
89302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89303       };
89304     } catch (std::exception& e) {
89305       {
89306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89307       };
89308     } catch (Dali::DaliException e) {
89309       {
89310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89311       };
89312     } catch (...) {
89313       {
89314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89315       };
89316     }
89317   }
89318
89319   jresult = (void *)result;
89320   return jresult;
89321 }
89322
89323
89324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89325   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89326
89327   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89328   {
89329     try {
89330       delete arg1;
89331     } catch (std::out_of_range& e) {
89332       {
89333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89334       };
89335     } catch (std::exception& e) {
89336       {
89337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89338       };
89339     } catch (Dali::DaliException e) {
89340       {
89341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89342       };
89343     } catch (...) {
89344       {
89345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89346       };
89347     }
89348   }
89349
89350 }
89351
89352
89353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89354   void * jresult ;
89355   Dali::BaseHandle arg1 ;
89356   Dali::BaseHandle *argp1 ;
89357   Dali::Toolkit::ProgressBar result;
89358
89359   argp1 = (Dali::BaseHandle *)jarg1;
89360   if (!argp1) {
89361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89362     return 0;
89363   }
89364   arg1 = *argp1;
89365   {
89366     try {
89367       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89368     } catch (std::out_of_range& e) {
89369       {
89370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89371       };
89372     } catch (std::exception& e) {
89373       {
89374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89375       };
89376     } catch (Dali::DaliException e) {
89377       {
89378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89379       };
89380     } catch (...) {
89381       {
89382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89383       };
89384     }
89385   }
89386
89387   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89388   return jresult;
89389 }
89390
89391
89392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89393   void * jresult ;
89394   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89395   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89396
89397   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89398   {
89399     try {
89400       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89401     } catch (std::out_of_range& e) {
89402       {
89403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89404       };
89405     } catch (std::exception& e) {
89406       {
89407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89408       };
89409     } catch (Dali::DaliException e) {
89410       {
89411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89412       };
89413     } catch (...) {
89414       {
89415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89416       };
89417     }
89418   }
89419
89420   jresult = (void *)result;
89421   return jresult;
89422 }
89423
89424
89425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89426   void * jresult ;
89427   Dali::Toolkit::GaussianBlurView *result = 0 ;
89428
89429   {
89430     try {
89431       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89432     } catch (std::out_of_range& e) {
89433       {
89434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89435       };
89436     } catch (std::exception& e) {
89437       {
89438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89439       };
89440     } catch (Dali::DaliException e) {
89441       {
89442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89443       };
89444     } catch (...) {
89445       {
89446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89447       };
89448     }
89449   }
89450
89451   jresult = (void *)result;
89452   return jresult;
89453 }
89454
89455
89456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89457   void * jresult ;
89458   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89459   Dali::Toolkit::GaussianBlurView *result = 0 ;
89460
89461   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89462   if (!arg1) {
89463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89464     return 0;
89465   }
89466   {
89467     try {
89468       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89469     } catch (std::out_of_range& e) {
89470       {
89471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89472       };
89473     } catch (std::exception& e) {
89474       {
89475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89476       };
89477     } catch (Dali::DaliException e) {
89478       {
89479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89480       };
89481     } catch (...) {
89482       {
89483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89484       };
89485     }
89486   }
89487
89488   jresult = (void *)result;
89489   return jresult;
89490 }
89491
89492
89493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89494   void * jresult ;
89495   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89496   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89497   Dali::Toolkit::GaussianBlurView *result = 0 ;
89498
89499   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89500   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89501   if (!arg2) {
89502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89503     return 0;
89504   }
89505   {
89506     try {
89507       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89508     } catch (std::out_of_range& e) {
89509       {
89510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89511       };
89512     } catch (std::exception& e) {
89513       {
89514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89515       };
89516     } catch (Dali::DaliException e) {
89517       {
89518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89519       };
89520     } catch (...) {
89521       {
89522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89523       };
89524     }
89525   }
89526
89527   jresult = (void *)result;
89528   return jresult;
89529 }
89530
89531
89532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89533   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89534
89535   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89536   {
89537     try {
89538       delete arg1;
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_DownCast(void * jarg1) {
89562   void * jresult ;
89563   Dali::BaseHandle arg1 ;
89564   Dali::BaseHandle *argp1 ;
89565   Dali::Toolkit::GaussianBlurView result;
89566
89567   argp1 = (Dali::BaseHandle *)jarg1;
89568   if (!argp1) {
89569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89570     return 0;
89571   }
89572   arg1 = *argp1;
89573   {
89574     try {
89575       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89576     } catch (std::out_of_range& e) {
89577       {
89578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89579       };
89580     } catch (std::exception& e) {
89581       {
89582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89583       };
89584     } catch (Dali::DaliException e) {
89585       {
89586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89587       };
89588     } catch (...) {
89589       {
89590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89591       };
89592     }
89593   }
89594
89595   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89596   return jresult;
89597 }
89598
89599
89600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89601   void * jresult ;
89602   Dali::Toolkit::GaussianBlurView result;
89603
89604   {
89605     try {
89606       result = Dali::Toolkit::GaussianBlurView::New();
89607     } catch (std::out_of_range& e) {
89608       {
89609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89610       };
89611     } catch (std::exception& e) {
89612       {
89613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89614       };
89615     } catch (Dali::DaliException e) {
89616       {
89617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89618       };
89619     } catch (...) {
89620       {
89621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89622       };
89623     }
89624   }
89625
89626   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89627   return jresult;
89628 }
89629
89630
89631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89632   void * jresult ;
89633   unsigned int arg1 ;
89634   float arg2 ;
89635   Dali::Pixel::Format arg3 ;
89636   float arg4 ;
89637   float arg5 ;
89638   bool arg6 ;
89639   Dali::Toolkit::GaussianBlurView result;
89640
89641   arg1 = (unsigned int)jarg1;
89642   arg2 = (float)jarg2;
89643   arg3 = (Dali::Pixel::Format)jarg3;
89644   arg4 = (float)jarg4;
89645   arg5 = (float)jarg5;
89646   arg6 = jarg6 ? true : false;
89647   {
89648     try {
89649       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89650     } catch (std::out_of_range& e) {
89651       {
89652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89653       };
89654     } catch (std::exception& e) {
89655       {
89656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89657       };
89658     } catch (Dali::DaliException e) {
89659       {
89660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89661       };
89662     } catch (...) {
89663       {
89664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89665       };
89666     }
89667   }
89668
89669   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89670   return jresult;
89671 }
89672
89673
89674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89675   void * jresult ;
89676   unsigned int arg1 ;
89677   float arg2 ;
89678   Dali::Pixel::Format arg3 ;
89679   float arg4 ;
89680   float arg5 ;
89681   Dali::Toolkit::GaussianBlurView result;
89682
89683   arg1 = (unsigned int)jarg1;
89684   arg2 = (float)jarg2;
89685   arg3 = (Dali::Pixel::Format)jarg3;
89686   arg4 = (float)jarg4;
89687   arg5 = (float)jarg5;
89688   {
89689     try {
89690       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89691     } catch (std::out_of_range& e) {
89692       {
89693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89694       };
89695     } catch (std::exception& e) {
89696       {
89697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89698       };
89699     } catch (Dali::DaliException e) {
89700       {
89701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89702       };
89703     } catch (...) {
89704       {
89705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89706       };
89707     }
89708   }
89709
89710   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89711   return jresult;
89712 }
89713
89714
89715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89716   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89717   Dali::Actor arg2 ;
89718   Dali::Actor *argp2 ;
89719
89720   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89721   argp2 = (Dali::Actor *)jarg2;
89722   if (!argp2) {
89723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89724     return ;
89725   }
89726   arg2 = *argp2;
89727   {
89728     try {
89729       (arg1)->Add(arg2);
89730     } catch (std::out_of_range& e) {
89731       {
89732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89733       };
89734     } catch (std::exception& e) {
89735       {
89736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89737       };
89738     } catch (Dali::DaliException e) {
89739       {
89740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89741       };
89742     } catch (...) {
89743       {
89744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89745       };
89746     }
89747   }
89748
89749 }
89750
89751
89752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89753   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89754   Dali::Actor arg2 ;
89755   Dali::Actor *argp2 ;
89756
89757   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89758   argp2 = (Dali::Actor *)jarg2;
89759   if (!argp2) {
89760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89761     return ;
89762   }
89763   arg2 = *argp2;
89764   {
89765     try {
89766       (arg1)->Remove(arg2);
89767     } catch (std::out_of_range& e) {
89768       {
89769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89770       };
89771     } catch (std::exception& e) {
89772       {
89773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89774       };
89775     } catch (Dali::DaliException e) {
89776       {
89777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89778       };
89779     } catch (...) {
89780       {
89781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89782       };
89783     }
89784   }
89785
89786 }
89787
89788
89789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89790   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89791
89792   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89793   {
89794     try {
89795       (arg1)->Activate();
89796     } catch (std::out_of_range& e) {
89797       {
89798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89799       };
89800     } catch (std::exception& e) {
89801       {
89802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89803       };
89804     } catch (Dali::DaliException e) {
89805       {
89806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89807       };
89808     } catch (...) {
89809       {
89810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89811       };
89812     }
89813   }
89814
89815 }
89816
89817
89818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89819   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89820
89821   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89822   {
89823     try {
89824       (arg1)->ActivateOnce();
89825     } catch (std::out_of_range& e) {
89826       {
89827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89828       };
89829     } catch (std::exception& e) {
89830       {
89831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89832       };
89833     } catch (Dali::DaliException e) {
89834       {
89835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89836       };
89837     } catch (...) {
89838       {
89839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89840       };
89841     }
89842   }
89843
89844 }
89845
89846
89847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89848   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89849
89850   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89851   {
89852     try {
89853       (arg1)->Deactivate();
89854     } catch (std::out_of_range& e) {
89855       {
89856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89857       };
89858     } catch (std::exception& e) {
89859       {
89860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89861       };
89862     } catch (Dali::DaliException e) {
89863       {
89864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89865       };
89866     } catch (...) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89869       };
89870     }
89871   }
89872
89873 }
89874
89875
89876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89877   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89878   Dali::Image arg2 ;
89879   Dali::FrameBufferImage arg3 ;
89880   Dali::Image *argp2 ;
89881   Dali::FrameBufferImage *argp3 ;
89882
89883   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89884   argp2 = (Dali::Image *)jarg2;
89885   if (!argp2) {
89886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89887     return ;
89888   }
89889   arg2 = *argp2;
89890   argp3 = (Dali::FrameBufferImage *)jarg3;
89891   if (!argp3) {
89892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89893     return ;
89894   }
89895   arg3 = *argp3;
89896   {
89897     try {
89898       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89899     } catch (std::out_of_range& e) {
89900       {
89901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89902       };
89903     } catch (std::exception& e) {
89904       {
89905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89906       };
89907     } catch (Dali::DaliException e) {
89908       {
89909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89910       };
89911     } catch (...) {
89912       {
89913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89914       };
89915     }
89916   }
89917
89918 }
89919
89920
89921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89922   int jresult ;
89923   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89924   Dali::Property::Index result;
89925
89926   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89927   {
89928     try {
89929       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89930     } catch (std::out_of_range& e) {
89931       {
89932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89933       };
89934     } catch (std::exception& e) {
89935       {
89936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89937       };
89938     } catch (Dali::DaliException e) {
89939       {
89940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89941       };
89942     } catch (...) {
89943       {
89944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89945       };
89946     }
89947   }
89948
89949   jresult = result;
89950   return jresult;
89951 }
89952
89953
89954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89955   void * jresult ;
89956   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89957   Dali::FrameBufferImage result;
89958
89959   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89960   {
89961     try {
89962       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89963     } catch (std::out_of_range& e) {
89964       {
89965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89966       };
89967     } catch (std::exception& e) {
89968       {
89969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89970       };
89971     } catch (Dali::DaliException e) {
89972       {
89973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89974       };
89975     } catch (...) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89978       };
89979     }
89980   }
89981
89982   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89983   return jresult;
89984 }
89985
89986
89987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89988   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89989   Dali::Vector4 *arg2 = 0 ;
89990
89991   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89992   arg2 = (Dali::Vector4 *)jarg2;
89993   if (!arg2) {
89994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89995     return ;
89996   }
89997   {
89998     try {
89999       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90000     } catch (std::out_of_range& e) {
90001       {
90002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90003       };
90004     } catch (std::exception& e) {
90005       {
90006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90007       };
90008     } catch (Dali::DaliException e) {
90009       {
90010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90011       };
90012     } catch (...) {
90013       {
90014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90015       };
90016     }
90017   }
90018
90019 }
90020
90021
90022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90023   void * jresult ;
90024   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90025   Dali::Vector4 result;
90026
90027   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90028   {
90029     try {
90030       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90031     } catch (std::out_of_range& e) {
90032       {
90033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90034       };
90035     } catch (std::exception& e) {
90036       {
90037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90038       };
90039     } catch (Dali::DaliException e) {
90040       {
90041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90042       };
90043     } catch (...) {
90044       {
90045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90046       };
90047     }
90048   }
90049
90050   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90051   return jresult;
90052 }
90053
90054
90055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90056   void * jresult ;
90057   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90058   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90059
90060   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90061   {
90062     try {
90063       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90064     } catch (std::out_of_range& e) {
90065       {
90066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90067       };
90068     } catch (std::exception& e) {
90069       {
90070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90071       };
90072     } catch (Dali::DaliException e) {
90073       {
90074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90075       };
90076     } catch (...) {
90077       {
90078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90079       };
90080     }
90081   }
90082
90083   jresult = (void *)result;
90084   return jresult;
90085 }
90086
90087
90088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90089   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90090
90091   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90092   {
90093     try {
90094       delete arg1;
90095     } catch (std::out_of_range& e) {
90096       {
90097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90098       };
90099     } catch (std::exception& e) {
90100       {
90101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90102       };
90103     } catch (Dali::DaliException e) {
90104       {
90105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90106       };
90107     } catch (...) {
90108       {
90109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90110       };
90111     }
90112   }
90113
90114 }
90115
90116
90117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90118   unsigned int jresult ;
90119   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90120   unsigned int result;
90121
90122   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90123   {
90124     try {
90125       result = (unsigned int)(arg1)->GetNumberOfPages();
90126     } catch (std::out_of_range& e) {
90127       {
90128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90129       };
90130     } catch (std::exception& e) {
90131       {
90132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90133       };
90134     } catch (Dali::DaliException e) {
90135       {
90136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90137       };
90138     } catch (...) {
90139       {
90140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90141       };
90142     }
90143   }
90144
90145   jresult = result;
90146   return jresult;
90147 }
90148
90149
90150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90151   void * jresult ;
90152   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90153   unsigned int arg2 ;
90154   Dali::Texture result;
90155
90156   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90157   arg2 = (unsigned int)jarg2;
90158   {
90159     try {
90160       result = (arg1)->NewPage(arg2);
90161     } catch (std::out_of_range& e) {
90162       {
90163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90164       };
90165     } catch (std::exception& e) {
90166       {
90167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90168       };
90169     } catch (Dali::DaliException e) {
90170       {
90171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90172       };
90173     } catch (...) {
90174       {
90175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90176       };
90177     }
90178   }
90179
90180   jresult = new Dali::Texture((const Dali::Texture &)result);
90181   return jresult;
90182 }
90183
90184
90185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90186   int jresult ;
90187   int result;
90188
90189   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90190   jresult = (int)result;
90191   return jresult;
90192 }
90193
90194
90195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90196   int jresult ;
90197   int result;
90198
90199   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90200   jresult = (int)result;
90201   return jresult;
90202 }
90203
90204
90205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90206   int jresult ;
90207   int result;
90208
90209   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90210   jresult = (int)result;
90211   return jresult;
90212 }
90213
90214
90215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90216   void * jresult ;
90217   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90218
90219   {
90220     try {
90221       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90222     } catch (std::out_of_range& e) {
90223       {
90224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90225       };
90226     } catch (std::exception& e) {
90227       {
90228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90229       };
90230     } catch (Dali::DaliException e) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90233       };
90234     } catch (...) {
90235       {
90236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90237       };
90238     }
90239   }
90240
90241   jresult = (void *)result;
90242   return jresult;
90243 }
90244
90245
90246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90247   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90248
90249   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90250   {
90251     try {
90252       delete arg1;
90253     } catch (std::out_of_range& e) {
90254       {
90255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90256       };
90257     } catch (std::exception& e) {
90258       {
90259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90260       };
90261     } catch (Dali::DaliException e) {
90262       {
90263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90264       };
90265     } catch (...) {
90266       {
90267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90268       };
90269     }
90270   }
90271
90272 }
90273
90274
90275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90276   void * jresult ;
90277   Dali::Toolkit::PageTurnView *result = 0 ;
90278
90279   {
90280     try {
90281       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90282     } catch (std::out_of_range& e) {
90283       {
90284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90285       };
90286     } catch (std::exception& e) {
90287       {
90288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90289       };
90290     } catch (Dali::DaliException e) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90293       };
90294     } catch (...) {
90295       {
90296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90297       };
90298     }
90299   }
90300
90301   jresult = (void *)result;
90302   return jresult;
90303 }
90304
90305
90306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90307   void * jresult ;
90308   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90309   Dali::Toolkit::PageTurnView *result = 0 ;
90310
90311   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90312   if (!arg1) {
90313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90314     return 0;
90315   }
90316   {
90317     try {
90318       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90319     } catch (std::out_of_range& e) {
90320       {
90321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90322       };
90323     } catch (std::exception& e) {
90324       {
90325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90326       };
90327     } catch (Dali::DaliException e) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90330       };
90331     } catch (...) {
90332       {
90333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90334       };
90335     }
90336   }
90337
90338   jresult = (void *)result;
90339   return jresult;
90340 }
90341
90342
90343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90344   void * jresult ;
90345   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90346   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90347   Dali::Toolkit::PageTurnView *result = 0 ;
90348
90349   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90350   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90351   if (!arg2) {
90352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90353     return 0;
90354   }
90355   {
90356     try {
90357       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90358     } catch (std::out_of_range& e) {
90359       {
90360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90361       };
90362     } catch (std::exception& e) {
90363       {
90364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90365       };
90366     } catch (Dali::DaliException e) {
90367       {
90368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90369       };
90370     } catch (...) {
90371       {
90372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90373       };
90374     }
90375   }
90376
90377   jresult = (void *)result;
90378   return jresult;
90379 }
90380
90381
90382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90383   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90384
90385   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90386   {
90387     try {
90388       delete arg1;
90389     } catch (std::out_of_range& e) {
90390       {
90391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90392       };
90393     } catch (std::exception& e) {
90394       {
90395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90396       };
90397     } catch (Dali::DaliException e) {
90398       {
90399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90400       };
90401     } catch (...) {
90402       {
90403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90404       };
90405     }
90406   }
90407
90408 }
90409
90410
90411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90412   void * jresult ;
90413   Dali::BaseHandle arg1 ;
90414   Dali::BaseHandle *argp1 ;
90415   Dali::Toolkit::PageTurnView result;
90416
90417   argp1 = (Dali::BaseHandle *)jarg1;
90418   if (!argp1) {
90419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90420     return 0;
90421   }
90422   arg1 = *argp1;
90423   {
90424     try {
90425       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90426     } catch (std::out_of_range& e) {
90427       {
90428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90429       };
90430     } catch (std::exception& e) {
90431       {
90432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90433       };
90434     } catch (Dali::DaliException e) {
90435       {
90436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90437       };
90438     } catch (...) {
90439       {
90440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90441       };
90442     }
90443   }
90444
90445   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90446   return jresult;
90447 }
90448
90449
90450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90451   void * jresult ;
90452   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90453   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90454
90455   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90456   {
90457     try {
90458       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90459     } catch (std::out_of_range& e) {
90460       {
90461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90462       };
90463     } catch (std::exception& e) {
90464       {
90465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90466       };
90467     } catch (Dali::DaliException e) {
90468       {
90469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90470       };
90471     } catch (...) {
90472       {
90473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90474       };
90475     }
90476   }
90477
90478   jresult = (void *)result;
90479   return jresult;
90480 }
90481
90482
90483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90484   void * jresult ;
90485   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90486   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90487
90488   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90489   {
90490     try {
90491       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90492     } catch (std::out_of_range& e) {
90493       {
90494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90495       };
90496     } catch (std::exception& e) {
90497       {
90498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90499       };
90500     } catch (Dali::DaliException e) {
90501       {
90502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90503       };
90504     } catch (...) {
90505       {
90506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90507       };
90508     }
90509   }
90510
90511   jresult = (void *)result;
90512   return jresult;
90513 }
90514
90515
90516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90517   void * jresult ;
90518   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90519   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90520
90521   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90522   {
90523     try {
90524       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90525     } catch (std::out_of_range& e) {
90526       {
90527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90528       };
90529     } catch (std::exception& e) {
90530       {
90531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90532       };
90533     } catch (Dali::DaliException e) {
90534       {
90535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90536       };
90537     } catch (...) {
90538       {
90539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90540       };
90541     }
90542   }
90543
90544   jresult = (void *)result;
90545   return jresult;
90546 }
90547
90548
90549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90550   void * jresult ;
90551   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90552   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90553
90554   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90555   {
90556     try {
90557       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90558     } catch (std::out_of_range& e) {
90559       {
90560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90561       };
90562     } catch (std::exception& e) {
90563       {
90564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90565       };
90566     } catch (Dali::DaliException e) {
90567       {
90568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90569       };
90570     } catch (...) {
90571       {
90572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90573       };
90574     }
90575   }
90576
90577   jresult = (void *)result;
90578   return jresult;
90579 }
90580
90581
90582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90583   void * jresult ;
90584   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90585
90586   {
90587     try {
90588       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90589     } catch (std::out_of_range& e) {
90590       {
90591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90592       };
90593     } catch (std::exception& e) {
90594       {
90595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90596       };
90597     } catch (Dali::DaliException e) {
90598       {
90599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90600       };
90601     } catch (...) {
90602       {
90603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90604       };
90605     }
90606   }
90607
90608   jresult = (void *)result;
90609   return jresult;
90610 }
90611
90612
90613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90614   void * jresult ;
90615   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90616   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90617
90618   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90619   if (!arg1) {
90620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90621     return 0;
90622   }
90623   {
90624     try {
90625       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
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_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90651   void * jresult ;
90652   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90653   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90654   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90655
90656   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90657   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90658   if (!arg2) {
90659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90660     return 0;
90661   }
90662   {
90663     try {
90664       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90665     } catch (std::out_of_range& e) {
90666       {
90667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90668       };
90669     } catch (std::exception& e) {
90670       {
90671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90672       };
90673     } catch (Dali::DaliException e) {
90674       {
90675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90676       };
90677     } catch (...) {
90678       {
90679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90680       };
90681     }
90682   }
90683
90684   jresult = (void *)result;
90685   return jresult;
90686 }
90687
90688
90689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90690   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90691
90692   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90693   {
90694     try {
90695       delete arg1;
90696     } catch (std::out_of_range& e) {
90697       {
90698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90699       };
90700     } catch (std::exception& e) {
90701       {
90702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90703       };
90704     } catch (Dali::DaliException e) {
90705       {
90706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90707       };
90708     } catch (...) {
90709       {
90710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90711       };
90712     }
90713   }
90714
90715 }
90716
90717
90718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90719   void * jresult ;
90720   Dali::Toolkit::PageFactory *arg1 = 0 ;
90721   Dali::Vector2 *arg2 = 0 ;
90722   Dali::Toolkit::PageTurnLandscapeView result;
90723
90724   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90725   if (!arg1) {
90726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90727     return 0;
90728   }
90729   arg2 = (Dali::Vector2 *)jarg2;
90730   if (!arg2) {
90731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90732     return 0;
90733   }
90734   {
90735     try {
90736       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
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::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90757   return jresult;
90758 }
90759
90760
90761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90762   void * jresult ;
90763   Dali::BaseHandle arg1 ;
90764   Dali::BaseHandle *argp1 ;
90765   Dali::Toolkit::PageTurnLandscapeView result;
90766
90767   argp1 = (Dali::BaseHandle *)jarg1;
90768   if (!argp1) {
90769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90770     return 0;
90771   }
90772   arg1 = *argp1;
90773   {
90774     try {
90775       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90776     } catch (std::out_of_range& e) {
90777       {
90778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90779       };
90780     } catch (std::exception& e) {
90781       {
90782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90783       };
90784     } catch (Dali::DaliException e) {
90785       {
90786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90787       };
90788     } catch (...) {
90789       {
90790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90791       };
90792     }
90793   }
90794
90795   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90796   return jresult;
90797 }
90798
90799
90800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90801   void * jresult ;
90802   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90803
90804   {
90805     try {
90806       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90807     } catch (std::out_of_range& e) {
90808       {
90809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90810       };
90811     } catch (std::exception& e) {
90812       {
90813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90814       };
90815     } catch (Dali::DaliException e) {
90816       {
90817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90818       };
90819     } catch (...) {
90820       {
90821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90822       };
90823     }
90824   }
90825
90826   jresult = (void *)result;
90827   return jresult;
90828 }
90829
90830
90831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90832   void * jresult ;
90833   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90834   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90835
90836   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90837   if (!arg1) {
90838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90839     return 0;
90840   }
90841   {
90842     try {
90843       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90844     } catch (std::out_of_range& e) {
90845       {
90846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90847       };
90848     } catch (std::exception& e) {
90849       {
90850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90851       };
90852     } catch (Dali::DaliException e) {
90853       {
90854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90855       };
90856     } catch (...) {
90857       {
90858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90859       };
90860     }
90861   }
90862
90863   jresult = (void *)result;
90864   return jresult;
90865 }
90866
90867
90868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90869   void * jresult ;
90870   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90871   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90872   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90873
90874   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90875   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90876   if (!arg2) {
90877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90878     return 0;
90879   }
90880   {
90881     try {
90882       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90883     } catch (std::out_of_range& e) {
90884       {
90885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90886       };
90887     } catch (std::exception& e) {
90888       {
90889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90890       };
90891     } catch (Dali::DaliException e) {
90892       {
90893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90894       };
90895     } catch (...) {
90896       {
90897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90898       };
90899     }
90900   }
90901
90902   jresult = (void *)result;
90903   return jresult;
90904 }
90905
90906
90907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90908   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90909
90910   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90911   {
90912     try {
90913       delete arg1;
90914     } catch (std::out_of_range& e) {
90915       {
90916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90917       };
90918     } catch (std::exception& e) {
90919       {
90920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90921       };
90922     } catch (Dali::DaliException e) {
90923       {
90924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90925       };
90926     } catch (...) {
90927       {
90928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90929       };
90930     }
90931   }
90932
90933 }
90934
90935
90936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90937   void * jresult ;
90938   Dali::Toolkit::PageFactory *arg1 = 0 ;
90939   Dali::Vector2 *arg2 = 0 ;
90940   Dali::Toolkit::PageTurnPortraitView result;
90941
90942   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90943   if (!arg1) {
90944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90945     return 0;
90946   }
90947   arg2 = (Dali::Vector2 *)jarg2;
90948   if (!arg2) {
90949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90950     return 0;
90951   }
90952   {
90953     try {
90954       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90955     } catch (std::out_of_range& e) {
90956       {
90957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90958       };
90959     } catch (std::exception& e) {
90960       {
90961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90962       };
90963     } catch (Dali::DaliException e) {
90964       {
90965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90966       };
90967     } catch (...) {
90968       {
90969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90970       };
90971     }
90972   }
90973
90974   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90975   return jresult;
90976 }
90977
90978
90979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90980   void * jresult ;
90981   Dali::BaseHandle arg1 ;
90982   Dali::BaseHandle *argp1 ;
90983   Dali::Toolkit::PageTurnPortraitView result;
90984
90985   argp1 = (Dali::BaseHandle *)jarg1;
90986   if (!argp1) {
90987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90988     return 0;
90989   }
90990   arg1 = *argp1;
90991   {
90992     try {
90993       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
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::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91014   return jresult;
91015 }
91016
91017
91018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91019   int jresult ;
91020   int result;
91021
91022   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91023   jresult = (int)result;
91024   return jresult;
91025 }
91026
91027
91028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91029   int jresult ;
91030   int result;
91031
91032   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91033   jresult = (int)result;
91034   return jresult;
91035 }
91036
91037
91038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91039   int jresult ;
91040   int result;
91041
91042   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91043   jresult = (int)result;
91044   return jresult;
91045 }
91046
91047
91048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91049   void * jresult ;
91050   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91051
91052   {
91053     try {
91054       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91055     } catch (std::out_of_range& e) {
91056       {
91057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91058       };
91059     } catch (std::exception& e) {
91060       {
91061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91062       };
91063     } catch (Dali::DaliException e) {
91064       {
91065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91066       };
91067     } catch (...) {
91068       {
91069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91070       };
91071     }
91072   }
91073
91074   jresult = (void *)result;
91075   return jresult;
91076 }
91077
91078
91079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91080   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91081
91082   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91083   {
91084     try {
91085       delete arg1;
91086     } catch (std::out_of_range& e) {
91087       {
91088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91089       };
91090     } catch (std::exception& e) {
91091       {
91092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91093       };
91094     } catch (Dali::DaliException e) {
91095       {
91096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91097       };
91098     } catch (...) {
91099       {
91100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91101       };
91102     }
91103   }
91104
91105 }
91106
91107
91108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91109   void * jresult ;
91110   Dali::Toolkit::ToggleButton *result = 0 ;
91111
91112   {
91113     try {
91114       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91115     } catch (std::out_of_range& e) {
91116       {
91117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91118       };
91119     } catch (std::exception& e) {
91120       {
91121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91122       };
91123     } catch (Dali::DaliException e) {
91124       {
91125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91126       };
91127     } catch (...) {
91128       {
91129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91130       };
91131     }
91132   }
91133
91134   jresult = (void *)result;
91135   return jresult;
91136 }
91137
91138
91139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91140   void * jresult ;
91141   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91142   Dali::Toolkit::ToggleButton *result = 0 ;
91143
91144   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91145   if (!arg1) {
91146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91147     return 0;
91148   }
91149   {
91150     try {
91151       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91152     } catch (std::out_of_range& e) {
91153       {
91154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91155       };
91156     } catch (std::exception& e) {
91157       {
91158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91159       };
91160     } catch (Dali::DaliException e) {
91161       {
91162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91163       };
91164     } catch (...) {
91165       {
91166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91167       };
91168     }
91169   }
91170
91171   jresult = (void *)result;
91172   return jresult;
91173 }
91174
91175
91176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91177   void * jresult ;
91178   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91179   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91180   Dali::Toolkit::ToggleButton *result = 0 ;
91181
91182   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91183   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91184   if (!arg2) {
91185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91186     return 0;
91187   }
91188   {
91189     try {
91190       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91191     } catch (std::out_of_range& e) {
91192       {
91193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91194       };
91195     } catch (std::exception& e) {
91196       {
91197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91198       };
91199     } catch (Dali::DaliException e) {
91200       {
91201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91202       };
91203     } catch (...) {
91204       {
91205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91206       };
91207     }
91208   }
91209
91210   jresult = (void *)result;
91211   return jresult;
91212 }
91213
91214
91215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91216   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91217
91218   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91219   {
91220     try {
91221       delete arg1;
91222     } catch (std::out_of_range& e) {
91223       {
91224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91225       };
91226     } catch (std::exception& e) {
91227       {
91228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91229       };
91230     } catch (Dali::DaliException e) {
91231       {
91232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91233       };
91234     } catch (...) {
91235       {
91236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91237       };
91238     }
91239   }
91240
91241 }
91242
91243
91244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91245   void * jresult ;
91246   Dali::Toolkit::ToggleButton result;
91247
91248   {
91249     try {
91250       result = Dali::Toolkit::ToggleButton::New();
91251     } catch (std::out_of_range& e) {
91252       {
91253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91254       };
91255     } catch (std::exception& e) {
91256       {
91257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91258       };
91259     } catch (Dali::DaliException e) {
91260       {
91261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91262       };
91263     } catch (...) {
91264       {
91265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91266       };
91267     }
91268   }
91269
91270   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91271   return jresult;
91272 }
91273
91274
91275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91276   void * jresult ;
91277   Dali::BaseHandle arg1 ;
91278   Dali::BaseHandle *argp1 ;
91279   Dali::Toolkit::ToggleButton result;
91280
91281   argp1 = (Dali::BaseHandle *)jarg1;
91282   if (!argp1) {
91283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91284     return 0;
91285   }
91286   arg1 = *argp1;
91287   {
91288     try {
91289       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91290     } catch (std::out_of_range& e) {
91291       {
91292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91293       };
91294     } catch (std::exception& e) {
91295       {
91296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91297       };
91298     } catch (Dali::DaliException e) {
91299       {
91300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91301       };
91302     } catch (...) {
91303       {
91304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91305       };
91306     }
91307   }
91308
91309   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91310   return jresult;
91311 }
91312
91313
91314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91315   void * jresult ;
91316   Dali::Toolkit::Visual::Base *result = 0 ;
91317
91318   {
91319     try {
91320       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91321     } catch (std::out_of_range& e) {
91322       {
91323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91324       };
91325     } catch (std::exception& e) {
91326       {
91327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91328       };
91329     } catch (Dali::DaliException e) {
91330       {
91331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91332       };
91333     } catch (...) {
91334       {
91335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91336       };
91337     }
91338   }
91339
91340   jresult = (void *)result;
91341   return jresult;
91342 }
91343
91344
91345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91346   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91347
91348   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91349   {
91350     try {
91351       delete arg1;
91352     } catch (std::out_of_range& e) {
91353       {
91354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91355       };
91356     } catch (std::exception& e) {
91357       {
91358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91359       };
91360     } catch (Dali::DaliException e) {
91361       {
91362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91363       };
91364     } catch (...) {
91365       {
91366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91367       };
91368     }
91369   }
91370
91371 }
91372
91373
91374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91375   void * jresult ;
91376   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91377   Dali::Toolkit::Visual::Base *result = 0 ;
91378
91379   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91380   if (!arg1) {
91381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91382     return 0;
91383   }
91384   {
91385     try {
91386       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91387     } catch (std::out_of_range& e) {
91388       {
91389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91390       };
91391     } catch (std::exception& e) {
91392       {
91393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91394       };
91395     } catch (Dali::DaliException e) {
91396       {
91397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91398       };
91399     } catch (...) {
91400       {
91401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91402       };
91403     }
91404   }
91405
91406   jresult = (void *)result;
91407   return jresult;
91408 }
91409
91410
91411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91412   void * jresult ;
91413   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91414   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91415   Dali::Toolkit::Visual::Base *result = 0 ;
91416
91417   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91418   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91419   if (!arg2) {
91420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91421     return 0;
91422   }
91423   {
91424     try {
91425       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91426     } catch (std::out_of_range& e) {
91427       {
91428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91429       };
91430     } catch (std::exception& e) {
91431       {
91432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91433       };
91434     } catch (Dali::DaliException e) {
91435       {
91436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91437       };
91438     } catch (...) {
91439       {
91440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91441       };
91442     }
91443   }
91444
91445   jresult = (void *)result;
91446   return jresult;
91447 }
91448
91449
91450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91451   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91452   std::string *arg2 = 0 ;
91453
91454   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91455   if (!jarg2) {
91456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91457     return ;
91458   }
91459   std::string arg2_str(jarg2);
91460   arg2 = &arg2_str;
91461   {
91462     try {
91463       (arg1)->SetName((std::string const &)*arg2);
91464     } catch (std::out_of_range& e) {
91465       {
91466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91467       };
91468     } catch (std::exception& e) {
91469       {
91470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91471       };
91472     } catch (Dali::DaliException e) {
91473       {
91474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91475       };
91476     } catch (...) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91479       };
91480     }
91481   }
91482
91483
91484   //argout typemap for const std::string&
91485
91486 }
91487
91488
91489 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91490   char * jresult ;
91491   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91492   std::string *result = 0 ;
91493
91494   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91495   {
91496     try {
91497       result = (std::string *) &(arg1)->GetName();
91498     } catch (std::out_of_range& e) {
91499       {
91500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91501       };
91502     } catch (std::exception& e) {
91503       {
91504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91505       };
91506     } catch (Dali::DaliException e) {
91507       {
91508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91509       };
91510     } catch (...) {
91511       {
91512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91513       };
91514     }
91515   }
91516
91517   jresult = SWIG_csharp_string_callback(result->c_str());
91518   return jresult;
91519 }
91520
91521
91522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91523   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91524   Dali::Property::Map *arg2 = 0 ;
91525   Dali::Size arg3 ;
91526   Dali::Size *argp3 ;
91527
91528   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91529   arg2 = (Dali::Property::Map *)jarg2;
91530   if (!arg2) {
91531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91532     return ;
91533   }
91534   argp3 = (Dali::Size *)jarg3;
91535   if (!argp3) {
91536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91537     return ;
91538   }
91539   arg3 = *argp3;
91540   {
91541     try {
91542       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91543     } catch (std::out_of_range& e) {
91544       {
91545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91546       };
91547     } catch (std::exception& e) {
91548       {
91549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91550       };
91551     } catch (Dali::DaliException e) {
91552       {
91553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91554       };
91555     } catch (...) {
91556       {
91557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91558       };
91559     }
91560   }
91561
91562 }
91563
91564
91565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91566   float jresult ;
91567   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91568   float arg2 ;
91569   float result;
91570
91571   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91572   arg2 = (float)jarg2;
91573   {
91574     try {
91575       result = (float)(arg1)->GetHeightForWidth(arg2);
91576     } catch (std::out_of_range& e) {
91577       {
91578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91579       };
91580     } catch (std::exception& e) {
91581       {
91582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91583       };
91584     } catch (Dali::DaliException e) {
91585       {
91586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91587       };
91588     } catch (...) {
91589       {
91590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91591       };
91592     }
91593   }
91594
91595   jresult = result;
91596   return jresult;
91597 }
91598
91599
91600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91601   float jresult ;
91602   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91603   float arg2 ;
91604   float result;
91605
91606   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91607   arg2 = (float)jarg2;
91608   {
91609     try {
91610       result = (float)(arg1)->GetWidthForHeight(arg2);
91611     } catch (std::out_of_range& e) {
91612       {
91613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91614       };
91615     } catch (std::exception& e) {
91616       {
91617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91618       };
91619     } catch (Dali::DaliException e) {
91620       {
91621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91622       };
91623     } catch (...) {
91624       {
91625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91626       };
91627     }
91628   }
91629
91630   jresult = result;
91631   return jresult;
91632 }
91633
91634
91635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91636   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91637   Dali::Vector2 *arg2 = 0 ;
91638
91639   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91640   arg2 = (Dali::Vector2 *)jarg2;
91641   if (!arg2) {
91642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91643     return ;
91644   }
91645   {
91646     try {
91647       (arg1)->GetNaturalSize(*arg2);
91648     } catch (std::out_of_range& e) {
91649       {
91650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91651       };
91652     } catch (std::exception& e) {
91653       {
91654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91655       };
91656     } catch (Dali::DaliException e) {
91657       {
91658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91659       };
91660     } catch (...) {
91661       {
91662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91663       };
91664     }
91665   }
91666
91667 }
91668
91669
91670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91671   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91672   float arg2 ;
91673
91674   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91675   arg2 = (int)jarg2;
91676   {
91677     try {
91678       (arg1)->SetDepthIndex(arg2);
91679     } catch (std::out_of_range& e) {
91680       {
91681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91682       };
91683     } catch (std::exception& e) {
91684       {
91685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91686       };
91687     } catch (Dali::DaliException e) {
91688       {
91689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91690       };
91691     } catch (...) {
91692       {
91693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91694       };
91695     }
91696   }
91697
91698 }
91699
91700
91701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91702   int jresult ;
91703   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91704   int result;
91705
91706   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91707   {
91708     try {
91709       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91710     } catch (std::out_of_range& e) {
91711       {
91712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91713       };
91714     } catch (std::exception& e) {
91715       {
91716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91717       };
91718     } catch (Dali::DaliException e) {
91719       {
91720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91721       };
91722     } catch (...) {
91723       {
91724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91725       };
91726     }
91727   }
91728
91729   jresult = result;
91730   return jresult;
91731 }
91732
91733
91734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91735   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91736   Dali::Property::Map *arg2 = 0 ;
91737
91738   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91739   arg2 = (Dali::Property::Map *)jarg2;
91740   if (!arg2) {
91741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91742     return ;
91743   }
91744   {
91745     try {
91746       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91747     } catch (std::out_of_range& e) {
91748       {
91749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91750       };
91751     } catch (std::exception& e) {
91752       {
91753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91754       };
91755     } catch (Dali::DaliException e) {
91756       {
91757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91758       };
91759     } catch (...) {
91760       {
91761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91762       };
91763     }
91764   }
91765
91766 }
91767
91768
91769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91770   void * jresult ;
91771   Dali::Toolkit::VisualFactory result;
91772
91773   {
91774     try {
91775       result = Dali::Toolkit::VisualFactory::Get();
91776     } catch (std::out_of_range& e) {
91777       {
91778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91779       };
91780     } catch (std::exception& e) {
91781       {
91782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91783       };
91784     } catch (Dali::DaliException e) {
91785       {
91786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91787       };
91788     } catch (...) {
91789       {
91790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91791       };
91792     }
91793   }
91794
91795   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91796   return jresult;
91797 }
91798
91799
91800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91801   void * jresult ;
91802   Dali::Toolkit::VisualFactory *result = 0 ;
91803
91804   {
91805     try {
91806       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91807     } catch (std::out_of_range& e) {
91808       {
91809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91810       };
91811     } catch (std::exception& e) {
91812       {
91813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91814       };
91815     } catch (Dali::DaliException e) {
91816       {
91817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91818       };
91819     } catch (...) {
91820       {
91821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91822       };
91823     }
91824   }
91825
91826   jresult = (void *)result;
91827   return jresult;
91828 }
91829
91830
91831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91832   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91833
91834   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91835   {
91836     try {
91837       delete arg1;
91838     } catch (std::out_of_range& e) {
91839       {
91840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91841       };
91842     } catch (std::exception& e) {
91843       {
91844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91845       };
91846     } catch (Dali::DaliException e) {
91847       {
91848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91849       };
91850     } catch (...) {
91851       {
91852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91853       };
91854     }
91855   }
91856
91857 }
91858
91859
91860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91861   void * jresult ;
91862   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91863   Dali::Toolkit::VisualFactory *result = 0 ;
91864
91865   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91866   if (!arg1) {
91867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91868     return 0;
91869   }
91870   {
91871     try {
91872       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91873     } catch (std::out_of_range& e) {
91874       {
91875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91876       };
91877     } catch (std::exception& e) {
91878       {
91879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91880       };
91881     } catch (Dali::DaliException e) {
91882       {
91883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91884       };
91885     } catch (...) {
91886       {
91887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91888       };
91889     }
91890   }
91891
91892   jresult = (void *)result;
91893   return jresult;
91894 }
91895
91896
91897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91898   void * jresult ;
91899   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91900   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91901   Dali::Toolkit::VisualFactory *result = 0 ;
91902
91903   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91904   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91905   if (!arg2) {
91906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91907     return 0;
91908   }
91909   {
91910     try {
91911       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (Dali::DaliException e) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91923       };
91924     } catch (...) {
91925       {
91926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91927       };
91928     }
91929   }
91930
91931   jresult = (void *)result;
91932   return jresult;
91933 }
91934
91935
91936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91937   void * jresult ;
91938   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91939   Dali::Property::Map *arg2 = 0 ;
91940   Dali::Toolkit::Visual::Base result;
91941
91942   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91943   arg2 = (Dali::Property::Map *)jarg2;
91944   if (!arg2) {
91945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91946     return 0;
91947   }
91948   {
91949     try {
91950       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
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::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91971   return jresult;
91972 }
91973
91974
91975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91976   void * jresult ;
91977   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91978   Dali::Image *arg2 = 0 ;
91979   Dali::Toolkit::Visual::Base result;
91980
91981   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91982   arg2 = (Dali::Image *)jarg2;
91983   if (!arg2) {
91984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91985     return 0;
91986   }
91987   {
91988     try {
91989       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
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::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92010   return jresult;
92011 }
92012
92013
92014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92015   void * jresult ;
92016   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92017   std::string *arg2 = 0 ;
92018   Dali::ImageDimensions arg3 ;
92019   Dali::ImageDimensions *argp3 ;
92020   Dali::Toolkit::Visual::Base result;
92021
92022   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92023   if (!jarg2) {
92024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92025     return 0;
92026   }
92027   std::string arg2_str(jarg2);
92028   arg2 = &arg2_str;
92029   argp3 = (Dali::ImageDimensions *)jarg3;
92030   if (!argp3) {
92031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92032     return 0;
92033   }
92034   arg3 = *argp3;
92035   {
92036     try {
92037       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92038     } catch (std::out_of_range& e) {
92039       {
92040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92041       };
92042     } catch (std::exception& e) {
92043       {
92044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92045       };
92046     } catch (Dali::DaliException e) {
92047       {
92048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92049       };
92050     } catch (...) {
92051       {
92052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92053       };
92054     }
92055   }
92056
92057   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92058
92059   //argout typemap for const std::string&
92060
92061   return jresult;
92062 }
92063
92064
92065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92066   void * jresult ;
92067   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92068
92069   {
92070     try {
92071       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92072     } catch (std::out_of_range& e) {
92073       {
92074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92075       };
92076     } catch (std::exception& e) {
92077       {
92078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92079       };
92080     } catch (Dali::DaliException e) {
92081       {
92082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92083       };
92084     } catch (...) {
92085       {
92086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92087       };
92088     }
92089   }
92090
92091   jresult = (void *)result;
92092   return jresult;
92093 }
92094
92095
92096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92097   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92098
92099   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92100   {
92101     try {
92102       delete arg1;
92103     } catch (std::out_of_range& e) {
92104       {
92105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92106       };
92107     } catch (std::exception& e) {
92108       {
92109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92110       };
92111     } catch (Dali::DaliException e) {
92112       {
92113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92114       };
92115     } catch (...) {
92116       {
92117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92118       };
92119     }
92120   }
92121
92122 }
92123
92124
92125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92126   void * jresult ;
92127   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92128   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92129
92130   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92131   if (!arg1) {
92132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92133     return 0;
92134   }
92135   {
92136     try {
92137       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
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 = (void *)result;
92158   return jresult;
92159 }
92160
92161
92162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92163   void * jresult ;
92164   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92165   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92166   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92167
92168   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92169   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92170   if (!arg2) {
92171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92172     return 0;
92173   }
92174   {
92175     try {
92176       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92177     } catch (std::out_of_range& e) {
92178       {
92179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92180       };
92181     } catch (std::exception& e) {
92182       {
92183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92184       };
92185     } catch (Dali::DaliException e) {
92186       {
92187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92188       };
92189     } catch (...) {
92190       {
92191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92192       };
92193     }
92194   }
92195
92196   jresult = (void *)result;
92197   return jresult;
92198 }
92199
92200
92201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92202   void * jresult ;
92203   Dali::Toolkit::AsyncImageLoader result;
92204
92205   {
92206     try {
92207       result = Dali::Toolkit::AsyncImageLoader::New();
92208     } catch (std::out_of_range& e) {
92209       {
92210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92211       };
92212     } catch (std::exception& e) {
92213       {
92214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92215       };
92216     } catch (Dali::DaliException e) {
92217       {
92218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92219       };
92220     } catch (...) {
92221       {
92222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92223       };
92224     }
92225   }
92226
92227   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92228   return jresult;
92229 }
92230
92231
92232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92233   void * jresult ;
92234   Dali::BaseHandle arg1 ;
92235   Dali::BaseHandle *argp1 ;
92236   Dali::Toolkit::AsyncImageLoader result;
92237
92238   argp1 = (Dali::BaseHandle *)jarg1;
92239   if (!argp1) {
92240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92241     return 0;
92242   }
92243   arg1 = *argp1;
92244   {
92245     try {
92246       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92247     } catch (std::out_of_range& e) {
92248       {
92249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92250       };
92251     } catch (std::exception& e) {
92252       {
92253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92254       };
92255     } catch (Dali::DaliException e) {
92256       {
92257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92258       };
92259     } catch (...) {
92260       {
92261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92262       };
92263     }
92264   }
92265
92266   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92267   return jresult;
92268 }
92269
92270
92271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92272   unsigned int jresult ;
92273   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92274   std::string *arg2 = 0 ;
92275   uint32_t result;
92276
92277   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92278   if (!jarg2) {
92279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92280     return 0;
92281   }
92282   std::string arg2_str(jarg2);
92283   arg2 = &arg2_str;
92284   {
92285     try {
92286       result = (arg1)->Load((std::string const &)*arg2);
92287     } catch (std::out_of_range& e) {
92288       {
92289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92290       };
92291     } catch (std::exception& e) {
92292       {
92293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92294       };
92295     } catch (Dali::DaliException e) {
92296       {
92297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92298       };
92299     } catch (...) {
92300       {
92301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92302       };
92303     }
92304   }
92305
92306   jresult = result;
92307
92308   //argout typemap for const std::string&
92309
92310   return jresult;
92311 }
92312
92313
92314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92315   unsigned int jresult ;
92316   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92317   std::string *arg2 = 0 ;
92318   Dali::ImageDimensions arg3 ;
92319   Dali::ImageDimensions *argp3 ;
92320   uint32_t result;
92321
92322   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92323   if (!jarg2) {
92324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92325     return 0;
92326   }
92327   std::string arg2_str(jarg2);
92328   arg2 = &arg2_str;
92329   argp3 = (Dali::ImageDimensions *)jarg3;
92330   if (!argp3) {
92331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92332     return 0;
92333   }
92334   arg3 = *argp3;
92335   {
92336     try {
92337       result = (arg1)->Load((std::string const &)*arg2,arg3);
92338     } catch (std::out_of_range& e) {
92339       {
92340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92341       };
92342     } catch (std::exception& e) {
92343       {
92344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92345       };
92346     } catch (Dali::DaliException e) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92349       };
92350     } catch (...) {
92351       {
92352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92353       };
92354     }
92355   }
92356
92357   jresult = result;
92358
92359   //argout typemap for const std::string&
92360
92361   return jresult;
92362 }
92363
92364
92365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92366   unsigned int jresult ;
92367   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92368   std::string *arg2 = 0 ;
92369   Dali::ImageDimensions arg3 ;
92370   Dali::FittingMode::Type arg4 ;
92371   Dali::SamplingMode::Type arg5 ;
92372   bool arg6 ;
92373   Dali::ImageDimensions *argp3 ;
92374   uint32_t result;
92375
92376   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92377   if (!jarg2) {
92378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92379     return 0;
92380   }
92381   std::string arg2_str(jarg2);
92382   arg2 = &arg2_str;
92383   argp3 = (Dali::ImageDimensions *)jarg3;
92384   if (!argp3) {
92385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92386     return 0;
92387   }
92388   arg3 = *argp3;
92389   arg4 = (Dali::FittingMode::Type)jarg4;
92390   arg5 = (Dali::SamplingMode::Type)jarg5;
92391   arg6 = jarg6 ? true : false;
92392   {
92393     try {
92394       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92395     } catch (std::out_of_range& e) {
92396       {
92397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92398       };
92399     } catch (std::exception& e) {
92400       {
92401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92402       };
92403     } catch (Dali::DaliException e) {
92404       {
92405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92406       };
92407     } catch (...) {
92408       {
92409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92410       };
92411     }
92412   }
92413
92414   jresult = result;
92415
92416   //argout typemap for const std::string&
92417
92418   return jresult;
92419 }
92420
92421
92422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92423   unsigned int jresult ;
92424   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92425   uint32_t arg2 ;
92426   bool result;
92427
92428   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92429   arg2 = (uint32_t)jarg2;
92430   {
92431     try {
92432       result = (bool)(arg1)->Cancel(arg2);
92433     } catch (std::out_of_range& e) {
92434       {
92435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (std::exception& e) {
92438       {
92439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92440       };
92441     } catch (Dali::DaliException e) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92444       };
92445     } catch (...) {
92446       {
92447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92448       };
92449     }
92450   }
92451
92452   jresult = result;
92453   return jresult;
92454 }
92455
92456
92457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92458   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92459
92460   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92461   {
92462     try {
92463       (arg1)->CancelAll();
92464     } catch (std::out_of_range& e) {
92465       {
92466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92467       };
92468     } catch (std::exception& e) {
92469       {
92470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92471       };
92472     } catch (Dali::DaliException e) {
92473       {
92474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92475       };
92476     } catch (...) {
92477       {
92478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92479       };
92480     }
92481   }
92482
92483 }
92484
92485
92486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92487   void * jresult ;
92488   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92489   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92490
92491   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92492   {
92493     try {
92494       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92495     } catch (std::out_of_range& e) {
92496       {
92497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92498       };
92499     } catch (std::exception& e) {
92500       {
92501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92502       };
92503     } catch (Dali::DaliException e) {
92504       {
92505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92506       };
92507     } catch (...) {
92508       {
92509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92510       };
92511     }
92512   }
92513
92514   jresult = (void *)result;
92515   return jresult;
92516 }
92517
92518
92519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92520   void * jresult ;
92521   std::string *arg1 = 0 ;
92522   Dali::PixelData result;
92523
92524   if (!jarg1) {
92525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92526     return 0;
92527   }
92528   std::string arg1_str(jarg1);
92529   arg1 = &arg1_str;
92530   {
92531     try {
92532       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92533     } catch (std::out_of_range& e) {
92534       {
92535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92536       };
92537     } catch (std::exception& e) {
92538       {
92539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92540       };
92541     } catch (Dali::DaliException e) {
92542       {
92543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92544       };
92545     } catch (...) {
92546       {
92547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92548       };
92549     }
92550   }
92551
92552   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92553
92554   //argout typemap for const std::string&
92555
92556   return jresult;
92557 }
92558
92559
92560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92561   void * jresult ;
92562   std::string *arg1 = 0 ;
92563   Dali::ImageDimensions arg2 ;
92564   Dali::ImageDimensions *argp2 ;
92565   Dali::PixelData result;
92566
92567   if (!jarg1) {
92568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92569     return 0;
92570   }
92571   std::string arg1_str(jarg1);
92572   arg1 = &arg1_str;
92573   argp2 = (Dali::ImageDimensions *)jarg2;
92574   if (!argp2) {
92575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92576     return 0;
92577   }
92578   arg2 = *argp2;
92579   {
92580     try {
92581       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92582     } catch (std::out_of_range& e) {
92583       {
92584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92585       };
92586     } catch (std::exception& e) {
92587       {
92588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92589       };
92590     } catch (Dali::DaliException e) {
92591       {
92592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92593       };
92594     } catch (...) {
92595       {
92596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92597       };
92598     }
92599   }
92600
92601   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92602
92603   //argout typemap for const std::string&
92604
92605   return jresult;
92606 }
92607
92608
92609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92610   void * jresult ;
92611   std::string *arg1 = 0 ;
92612   Dali::ImageDimensions arg2 ;
92613   Dali::FittingMode::Type arg3 ;
92614   Dali::SamplingMode::Type arg4 ;
92615   bool arg5 ;
92616   Dali::ImageDimensions *argp2 ;
92617   Dali::PixelData result;
92618
92619   if (!jarg1) {
92620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92621     return 0;
92622   }
92623   std::string arg1_str(jarg1);
92624   arg1 = &arg1_str;
92625   argp2 = (Dali::ImageDimensions *)jarg2;
92626   if (!argp2) {
92627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92628     return 0;
92629   }
92630   arg2 = *argp2;
92631   arg3 = (Dali::FittingMode::Type)jarg3;
92632   arg4 = (Dali::SamplingMode::Type)jarg4;
92633   arg5 = jarg5 ? true : false;
92634   {
92635     try {
92636       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92637     } catch (std::out_of_range& e) {
92638       {
92639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92640       };
92641     } catch (std::exception& e) {
92642       {
92643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92644       };
92645     } catch (Dali::DaliException e) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92648       };
92649     } catch (...) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92652       };
92653     }
92654   }
92655
92656   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92657
92658   //argout typemap for const std::string&
92659
92660   return jresult;
92661 }
92662
92663
92664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92665   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92666
92667   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92668   {
92669     try {
92670       delete arg1;
92671     } catch (std::out_of_range& e) {
92672       {
92673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92674       };
92675     } catch (std::exception& e) {
92676       {
92677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92678       };
92679     } catch (Dali::DaliException e) {
92680       {
92681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92682       };
92683     } catch (...) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92686       };
92687     }
92688   }
92689
92690 }
92691
92692
92693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92694   void * jresult ;
92695   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92696   Dali::Actor arg2 ;
92697   Dali::Actor arg3 ;
92698   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92699   Dali::Actor *argp2 ;
92700   Dali::Actor *argp3 ;
92701   Dali::Actor result;
92702
92703   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92704   argp2 = (Dali::Actor *)jarg2;
92705   if (!argp2) {
92706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92707     return 0;
92708   }
92709   arg2 = *argp2;
92710   argp3 = (Dali::Actor *)jarg3;
92711   if (!argp3) {
92712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92713     return 0;
92714   }
92715   arg3 = *argp3;
92716   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92717   {
92718     try {
92719       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92720     } catch (std::out_of_range& e) {
92721       {
92722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92723       };
92724     } catch (std::exception& e) {
92725       {
92726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92727       };
92728     } catch (Dali::DaliException e) {
92729       {
92730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92731       };
92732     } catch (...) {
92733       {
92734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92735       };
92736     }
92737   }
92738
92739   jresult = new Dali::Actor((const Dali::Actor &)result);
92740   return jresult;
92741 }
92742
92743
92744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92745   void * jresult ;
92746   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92747
92748   {
92749     try {
92750       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92751     } catch (std::out_of_range& e) {
92752       {
92753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92754       };
92755     } catch (std::exception& e) {
92756       {
92757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92758       };
92759     } catch (Dali::DaliException e) {
92760       {
92761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92762       };
92763     } catch (...) {
92764       {
92765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92766       };
92767     }
92768   }
92769
92770   jresult = (void *)result;
92771   return jresult;
92772 }
92773
92774
92775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92776   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92777   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92778   if (director) {
92779     director->swig_connect_director(callback0);
92780   }
92781 }
92782
92783
92784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92785   KeyboardFocusManager arg1 ;
92786   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92787   KeyboardFocusManager *argp1 ;
92788
92789   argp1 = (KeyboardFocusManager *)jarg1;
92790   if (!argp1) {
92791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92792     return ;
92793   }
92794   arg1 = *argp1;
92795   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92796   if (!arg2) {
92797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92798     return ;
92799   }
92800   {
92801     try {
92802       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92803     } catch (std::out_of_range& e) {
92804       {
92805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92806       };
92807     } catch (std::exception& e) {
92808       {
92809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92810       };
92811     } catch (Dali::DaliException e) {
92812       {
92813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92814       };
92815     } catch (...) {
92816       {
92817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92818       };
92819     }
92820   }
92821
92822 }
92823
92824
92825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92826   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92827
92828   arg1 = (std::vector< unsigned int > *)jarg1;
92829   {
92830     try {
92831       (arg1)->clear();
92832     } catch (std::out_of_range& e) {
92833       {
92834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92835       };
92836     } catch (std::exception& e) {
92837       {
92838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92839       };
92840     } catch (Dali::DaliException e) {
92841       {
92842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92843       };
92844     } catch (...) {
92845       {
92846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92847       };
92848     }
92849   }
92850
92851 }
92852
92853
92854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92855   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92856   unsigned int *arg2 = 0 ;
92857   unsigned int temp2 ;
92858
92859   arg1 = (std::vector< unsigned int > *)jarg1;
92860   temp2 = (unsigned int)jarg2;
92861   arg2 = &temp2;
92862   {
92863     try {
92864       (arg1)->push_back((unsigned int const &)*arg2);
92865     } catch (std::out_of_range& e) {
92866       {
92867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92868       };
92869     } catch (std::exception& e) {
92870       {
92871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92872       };
92873     } catch (Dali::DaliException e) {
92874       {
92875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92876       };
92877     } catch (...) {
92878       {
92879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92880       };
92881     }
92882   }
92883
92884 }
92885
92886
92887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92888   unsigned long jresult ;
92889   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92890   std::vector< unsigned int >::size_type result;
92891
92892   arg1 = (std::vector< unsigned int > *)jarg1;
92893   {
92894     try {
92895       result = ((std::vector< unsigned int > const *)arg1)->size();
92896     } catch (std::out_of_range& e) {
92897       {
92898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92899       };
92900     } catch (std::exception& e) {
92901       {
92902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92903       };
92904     } catch (Dali::DaliException e) {
92905       {
92906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92907       };
92908     } catch (...) {
92909       {
92910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92911       };
92912     }
92913   }
92914
92915   jresult = (unsigned long)result;
92916   return jresult;
92917 }
92918
92919
92920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92921   unsigned long jresult ;
92922   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92923   std::vector< unsigned int >::size_type result;
92924
92925   arg1 = (std::vector< unsigned int > *)jarg1;
92926   {
92927     try {
92928       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92929     } catch (std::out_of_range& e) {
92930       {
92931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92932       };
92933     } catch (std::exception& e) {
92934       {
92935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92936       };
92937     } catch (Dali::DaliException e) {
92938       {
92939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92940       };
92941     } catch (...) {
92942       {
92943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92944       };
92945     }
92946   }
92947
92948   jresult = (unsigned long)result;
92949   return jresult;
92950 }
92951
92952
92953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92954   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92955   std::vector< unsigned int >::size_type arg2 ;
92956
92957   arg1 = (std::vector< unsigned int > *)jarg1;
92958   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92959   {
92960     try {
92961       (arg1)->reserve(arg2);
92962     } catch (std::out_of_range& e) {
92963       {
92964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92965       };
92966     } catch (std::exception& e) {
92967       {
92968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92969       };
92970     } catch (Dali::DaliException e) {
92971       {
92972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92973       };
92974     } catch (...) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92977       };
92978     }
92979   }
92980
92981 }
92982
92983
92984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92985   void * jresult ;
92986   std::vector< unsigned int > *result = 0 ;
92987
92988   {
92989     try {
92990       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92991     } catch (std::out_of_range& e) {
92992       {
92993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92994       };
92995     } catch (std::exception& e) {
92996       {
92997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92998       };
92999     } catch (Dali::DaliException e) {
93000       {
93001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93002       };
93003     } catch (...) {
93004       {
93005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93006       };
93007     }
93008   }
93009
93010   jresult = (void *)result;
93011   return jresult;
93012 }
93013
93014
93015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93016   void * jresult ;
93017   std::vector< unsigned int > *arg1 = 0 ;
93018   std::vector< unsigned int > *result = 0 ;
93019
93020   arg1 = (std::vector< unsigned int > *)jarg1;
93021   if (!arg1) {
93022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93023     return 0;
93024   }
93025   {
93026     try {
93027       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93028     } catch (std::out_of_range& e) {
93029       {
93030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93031       };
93032     } catch (std::exception& e) {
93033       {
93034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93035       };
93036     } catch (Dali::DaliException e) {
93037       {
93038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93039       };
93040     } catch (...) {
93041       {
93042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93043       };
93044     }
93045   }
93046
93047   jresult = (void *)result;
93048   return jresult;
93049 }
93050
93051
93052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93053   void * jresult ;
93054   int arg1 ;
93055   std::vector< unsigned int > *result = 0 ;
93056
93057   arg1 = (int)jarg1;
93058   {
93059     try {
93060       try {
93061         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93062       }
93063       catch(std::out_of_range &_e) {
93064         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93065         return 0;
93066       }
93067
93068     } catch (std::out_of_range& e) {
93069       {
93070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93071       };
93072     } catch (std::exception& e) {
93073       {
93074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93075       };
93076     } catch (Dali::DaliException e) {
93077       {
93078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93079       };
93080     } catch (...) {
93081       {
93082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93083       };
93084     }
93085   }
93086
93087   jresult = (void *)result;
93088   return jresult;
93089 }
93090
93091
93092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93093   unsigned int jresult ;
93094   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93095   int arg2 ;
93096   unsigned int result;
93097
93098   arg1 = (std::vector< unsigned int > *)jarg1;
93099   arg2 = (int)jarg2;
93100   {
93101     try {
93102       try {
93103         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93104       }
93105       catch(std::out_of_range &_e) {
93106         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93107         return 0;
93108       }
93109
93110     } catch (std::out_of_range& e) {
93111       {
93112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93113       };
93114     } catch (std::exception& e) {
93115       {
93116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93117       };
93118     } catch (Dali::DaliException e) {
93119       {
93120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93121       };
93122     } catch (...) {
93123       {
93124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93125       };
93126     }
93127   }
93128
93129   jresult = result;
93130   return jresult;
93131 }
93132
93133
93134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93135   unsigned int jresult ;
93136   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93137   int arg2 ;
93138   unsigned int *result = 0 ;
93139
93140   arg1 = (std::vector< unsigned int > *)jarg1;
93141   arg2 = (int)jarg2;
93142   {
93143     try {
93144       try {
93145         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93146       }
93147       catch(std::out_of_range &_e) {
93148         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93149         return 0;
93150       }
93151
93152     } catch (std::out_of_range& e) {
93153       {
93154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93155       };
93156     } catch (std::exception& e) {
93157       {
93158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93159       };
93160     } catch (Dali::DaliException e) {
93161       {
93162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93163       };
93164     } catch (...) {
93165       {
93166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93167       };
93168     }
93169   }
93170
93171   jresult = *result;
93172   return jresult;
93173 }
93174
93175
93176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93177   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93178   int arg2 ;
93179   unsigned int *arg3 = 0 ;
93180   unsigned int temp3 ;
93181
93182   arg1 = (std::vector< unsigned int > *)jarg1;
93183   arg2 = (int)jarg2;
93184   temp3 = (unsigned int)jarg3;
93185   arg3 = &temp3;
93186   {
93187     try {
93188       try {
93189         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93190       }
93191       catch(std::out_of_range &_e) {
93192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93193         return ;
93194       }
93195
93196     } catch (std::out_of_range& e) {
93197       {
93198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93199       };
93200     } catch (std::exception& e) {
93201       {
93202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93203       };
93204     } catch (Dali::DaliException e) {
93205       {
93206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93207       };
93208     } catch (...) {
93209       {
93210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93211       };
93212     }
93213   }
93214
93215 }
93216
93217
93218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93219   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93220   std::vector< unsigned int > *arg2 = 0 ;
93221
93222   arg1 = (std::vector< unsigned int > *)jarg1;
93223   arg2 = (std::vector< unsigned int > *)jarg2;
93224   if (!arg2) {
93225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93226     return ;
93227   }
93228   {
93229     try {
93230       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93231     } catch (std::out_of_range& e) {
93232       {
93233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93234       };
93235     } catch (std::exception& e) {
93236       {
93237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93238       };
93239     } catch (Dali::DaliException e) {
93240       {
93241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93242       };
93243     } catch (...) {
93244       {
93245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93246       };
93247     }
93248   }
93249
93250 }
93251
93252
93253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93254   void * jresult ;
93255   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93256   int arg2 ;
93257   int arg3 ;
93258   std::vector< unsigned int > *result = 0 ;
93259
93260   arg1 = (std::vector< unsigned int > *)jarg1;
93261   arg2 = (int)jarg2;
93262   arg3 = (int)jarg3;
93263   {
93264     try {
93265       try {
93266         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93267       }
93268       catch(std::out_of_range &_e) {
93269         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93270         return 0;
93271       }
93272       catch(std::invalid_argument &_e) {
93273         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93274         return 0;
93275       }
93276
93277     } catch (std::out_of_range& e) {
93278       {
93279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93280       };
93281     } catch (std::exception& e) {
93282       {
93283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93284       };
93285     } catch (Dali::DaliException e) {
93286       {
93287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93288       };
93289     } catch (...) {
93290       {
93291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93292       };
93293     }
93294   }
93295
93296   jresult = (void *)result;
93297   return jresult;
93298 }
93299
93300
93301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93302   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93303   int arg2 ;
93304   unsigned int *arg3 = 0 ;
93305   unsigned int temp3 ;
93306
93307   arg1 = (std::vector< unsigned int > *)jarg1;
93308   arg2 = (int)jarg2;
93309   temp3 = (unsigned int)jarg3;
93310   arg3 = &temp3;
93311   {
93312     try {
93313       try {
93314         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93315       }
93316       catch(std::out_of_range &_e) {
93317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93318         return ;
93319       }
93320
93321     } catch (std::out_of_range& e) {
93322       {
93323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93324       };
93325     } catch (std::exception& e) {
93326       {
93327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93328       };
93329     } catch (Dali::DaliException e) {
93330       {
93331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93332       };
93333     } catch (...) {
93334       {
93335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93336       };
93337     }
93338   }
93339
93340 }
93341
93342
93343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93344   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93345   int arg2 ;
93346   std::vector< unsigned int > *arg3 = 0 ;
93347
93348   arg1 = (std::vector< unsigned int > *)jarg1;
93349   arg2 = (int)jarg2;
93350   arg3 = (std::vector< unsigned int > *)jarg3;
93351   if (!arg3) {
93352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93353     return ;
93354   }
93355   {
93356     try {
93357       try {
93358         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93359       }
93360       catch(std::out_of_range &_e) {
93361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93362         return ;
93363       }
93364
93365     } catch (std::out_of_range& e) {
93366       {
93367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93368       };
93369     } catch (std::exception& e) {
93370       {
93371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93372       };
93373     } catch (Dali::DaliException e) {
93374       {
93375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93376       };
93377     } catch (...) {
93378       {
93379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93380       };
93381     }
93382   }
93383
93384 }
93385
93386
93387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93388   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93389   int arg2 ;
93390
93391   arg1 = (std::vector< unsigned int > *)jarg1;
93392   arg2 = (int)jarg2;
93393   {
93394     try {
93395       try {
93396         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93397       }
93398       catch(std::out_of_range &_e) {
93399         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93400         return ;
93401       }
93402
93403     } catch (std::out_of_range& e) {
93404       {
93405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93406       };
93407     } catch (std::exception& e) {
93408       {
93409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93410       };
93411     } catch (Dali::DaliException e) {
93412       {
93413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93414       };
93415     } catch (...) {
93416       {
93417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93418       };
93419     }
93420   }
93421
93422 }
93423
93424
93425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93426   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93427   int arg2 ;
93428   int arg3 ;
93429
93430   arg1 = (std::vector< unsigned int > *)jarg1;
93431   arg2 = (int)jarg2;
93432   arg3 = (int)jarg3;
93433   {
93434     try {
93435       try {
93436         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93437       }
93438       catch(std::out_of_range &_e) {
93439         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93440         return ;
93441       }
93442       catch(std::invalid_argument &_e) {
93443         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93444         return ;
93445       }
93446
93447     } catch (std::out_of_range& e) {
93448       {
93449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93450       };
93451     } catch (std::exception& e) {
93452       {
93453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93454       };
93455     } catch (Dali::DaliException e) {
93456       {
93457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93458       };
93459     } catch (...) {
93460       {
93461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93462       };
93463     }
93464   }
93465
93466 }
93467
93468
93469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93470   void * jresult ;
93471   unsigned int *arg1 = 0 ;
93472   int arg2 ;
93473   unsigned int temp1 ;
93474   std::vector< unsigned int > *result = 0 ;
93475
93476   temp1 = (unsigned int)jarg1;
93477   arg1 = &temp1;
93478   arg2 = (int)jarg2;
93479   {
93480     try {
93481       try {
93482         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93483       }
93484       catch(std::out_of_range &_e) {
93485         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93486         return 0;
93487       }
93488
93489     } catch (std::out_of_range& e) {
93490       {
93491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93492       };
93493     } catch (std::exception& e) {
93494       {
93495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93496       };
93497     } catch (Dali::DaliException e) {
93498       {
93499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93500       };
93501     } catch (...) {
93502       {
93503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93504       };
93505     }
93506   }
93507
93508   jresult = (void *)result;
93509   return jresult;
93510 }
93511
93512
93513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93514   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93515
93516   arg1 = (std::vector< unsigned int > *)jarg1;
93517   {
93518     try {
93519       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93520     } catch (std::out_of_range& e) {
93521       {
93522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93523       };
93524     } catch (std::exception& e) {
93525       {
93526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93527       };
93528     } catch (Dali::DaliException e) {
93529       {
93530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93531       };
93532     } catch (...) {
93533       {
93534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93535       };
93536     }
93537   }
93538
93539 }
93540
93541
93542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93543   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93544   int arg2 ;
93545   int arg3 ;
93546
93547   arg1 = (std::vector< unsigned int > *)jarg1;
93548   arg2 = (int)jarg2;
93549   arg3 = (int)jarg3;
93550   {
93551     try {
93552       try {
93553         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93554       }
93555       catch(std::out_of_range &_e) {
93556         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93557         return ;
93558       }
93559       catch(std::invalid_argument &_e) {
93560         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93561         return ;
93562       }
93563
93564     } catch (std::out_of_range& e) {
93565       {
93566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93567       };
93568     } catch (std::exception& e) {
93569       {
93570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93571       };
93572     } catch (Dali::DaliException e) {
93573       {
93574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93575       };
93576     } catch (...) {
93577       {
93578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93579       };
93580     }
93581   }
93582
93583 }
93584
93585
93586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93587   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93588   int arg2 ;
93589   std::vector< unsigned int > *arg3 = 0 ;
93590
93591   arg1 = (std::vector< unsigned int > *)jarg1;
93592   arg2 = (int)jarg2;
93593   arg3 = (std::vector< unsigned int > *)jarg3;
93594   if (!arg3) {
93595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93596     return ;
93597   }
93598   {
93599     try {
93600       try {
93601         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93602       }
93603       catch(std::out_of_range &_e) {
93604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93605         return ;
93606       }
93607
93608     } catch (std::out_of_range& e) {
93609       {
93610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93611       };
93612     } catch (std::exception& e) {
93613       {
93614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93615       };
93616     } catch (Dali::DaliException e) {
93617       {
93618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93619       };
93620     } catch (...) {
93621       {
93622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93623       };
93624     }
93625   }
93626
93627 }
93628
93629
93630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93631   unsigned int jresult ;
93632   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93633   unsigned int *arg2 = 0 ;
93634   unsigned int temp2 ;
93635   bool result;
93636
93637   arg1 = (std::vector< unsigned int > *)jarg1;
93638   temp2 = (unsigned int)jarg2;
93639   arg2 = &temp2;
93640   {
93641     try {
93642       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93643     } catch (std::out_of_range& e) {
93644       {
93645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93646       };
93647     } catch (std::exception& e) {
93648       {
93649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93650       };
93651     } catch (Dali::DaliException e) {
93652       {
93653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93654       };
93655     } catch (...) {
93656       {
93657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93658       };
93659     }
93660   }
93661
93662   jresult = result;
93663   return jresult;
93664 }
93665
93666
93667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93668   int jresult ;
93669   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93670   unsigned int *arg2 = 0 ;
93671   unsigned int temp2 ;
93672   int result;
93673
93674   arg1 = (std::vector< unsigned int > *)jarg1;
93675   temp2 = (unsigned int)jarg2;
93676   arg2 = &temp2;
93677   {
93678     try {
93679       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93680     } catch (std::out_of_range& e) {
93681       {
93682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93683       };
93684     } catch (std::exception& e) {
93685       {
93686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93687       };
93688     } catch (Dali::DaliException e) {
93689       {
93690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93691       };
93692     } catch (...) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93695       };
93696     }
93697   }
93698
93699   jresult = result;
93700   return jresult;
93701 }
93702
93703
93704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93705   int jresult ;
93706   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93707   unsigned int *arg2 = 0 ;
93708   unsigned int temp2 ;
93709   int result;
93710
93711   arg1 = (std::vector< unsigned int > *)jarg1;
93712   temp2 = (unsigned int)jarg2;
93713   arg2 = &temp2;
93714   {
93715     try {
93716       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93717     } catch (std::out_of_range& e) {
93718       {
93719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93720       };
93721     } catch (std::exception& e) {
93722       {
93723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93724       };
93725     } catch (Dali::DaliException e) {
93726       {
93727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93728       };
93729     } catch (...) {
93730       {
93731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93732       };
93733     }
93734   }
93735
93736   jresult = result;
93737   return jresult;
93738 }
93739
93740
93741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93742   unsigned int jresult ;
93743   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93744   unsigned int *arg2 = 0 ;
93745   unsigned int temp2 ;
93746   bool result;
93747
93748   arg1 = (std::vector< unsigned int > *)jarg1;
93749   temp2 = (unsigned int)jarg2;
93750   arg2 = &temp2;
93751   {
93752     try {
93753       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93754     } catch (std::out_of_range& e) {
93755       {
93756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93757       };
93758     } catch (std::exception& e) {
93759       {
93760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93761       };
93762     } catch (Dali::DaliException e) {
93763       {
93764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93765       };
93766     } catch (...) {
93767       {
93768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93769       };
93770     }
93771   }
93772
93773   jresult = result;
93774   return jresult;
93775 }
93776
93777
93778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93779   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93780
93781   arg1 = (std::vector< unsigned int > *)jarg1;
93782   {
93783     try {
93784       delete arg1;
93785     } catch (std::out_of_range& e) {
93786       {
93787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93788       };
93789     } catch (std::exception& e) {
93790       {
93791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93792       };
93793     } catch (Dali::DaliException e) {
93794       {
93795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93796       };
93797     } catch (...) {
93798       {
93799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93800       };
93801     }
93802   }
93803
93804 }
93805
93806
93807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93808   void * jresult ;
93809   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93810
93811   {
93812     try {
93813       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93814     } catch (std::out_of_range& e) {
93815       {
93816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93817       };
93818     } catch (std::exception& e) {
93819       {
93820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93821       };
93822     } catch (Dali::DaliException e) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93825       };
93826     } catch (...) {
93827       {
93828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93829       };
93830     }
93831   }
93832
93833   jresult = (void *)result;
93834   return jresult;
93835 }
93836
93837
93838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93839   void * jresult ;
93840   unsigned int arg1 ;
93841   Dali::Actor arg2 ;
93842   Dali::Actor *argp2 ;
93843   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93844
93845   arg1 = (unsigned int)jarg1;
93846   argp2 = (Dali::Actor *)jarg2;
93847   if (!argp2) {
93848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93849     return 0;
93850   }
93851   arg2 = *argp2;
93852   {
93853     try {
93854       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93855     } catch (std::out_of_range& e) {
93856       {
93857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93858       };
93859     } catch (std::exception& e) {
93860       {
93861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93862       };
93863     } catch (Dali::DaliException e) {
93864       {
93865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93866       };
93867     } catch (...) {
93868       {
93869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93870       };
93871     }
93872   }
93873
93874   jresult = (void *)result;
93875   return jresult;
93876 }
93877
93878
93879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93880   void * jresult ;
93881   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93882   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93883
93884   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93885   if (!arg1) {
93886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93887     return 0;
93888   }
93889   {
93890     try {
93891       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93892     } catch (std::out_of_range& e) {
93893       {
93894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93895       };
93896     } catch (std::exception& e) {
93897       {
93898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93899       };
93900     } catch (Dali::DaliException e) {
93901       {
93902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93903       };
93904     } catch (...) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93907       };
93908     }
93909   }
93910
93911   jresult = (void *)result;
93912   return jresult;
93913 }
93914
93915
93916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93917   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93918   unsigned int arg2 ;
93919
93920   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93921   arg2 = (unsigned int)jarg2;
93922   if (arg1) (arg1)->first = arg2;
93923 }
93924
93925
93926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93927   unsigned int jresult ;
93928   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93929   unsigned int result;
93930
93931   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93932   result = (unsigned int) ((arg1)->first);
93933   jresult = result;
93934   return jresult;
93935 }
93936
93937
93938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93939   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93940   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93941
93942   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93943   arg2 = (Dali::Actor *)jarg2;
93944   if (arg1) (arg1)->second = *arg2;
93945 }
93946
93947
93948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93949   void * jresult ;
93950   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93951   Dali::Actor *result = 0 ;
93952
93953   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93954   result = (Dali::Actor *)& ((arg1)->second);
93955   jresult = (void *)result;
93956   return jresult;
93957 }
93958
93959
93960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93961   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93962
93963   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93964   {
93965     try {
93966       delete arg1;
93967     } catch (std::out_of_range& e) {
93968       {
93969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93970       };
93971     } catch (std::exception& e) {
93972       {
93973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93974       };
93975     } catch (Dali::DaliException e) {
93976       {
93977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93978       };
93979     } catch (...) {
93980       {
93981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93982       };
93983     }
93984   }
93985
93986 }
93987
93988
93989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93990   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93991
93992   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93993   {
93994     try {
93995       (arg1)->clear();
93996     } catch (std::out_of_range& e) {
93997       {
93998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93999       };
94000     } catch (std::exception& e) {
94001       {
94002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94003       };
94004     } catch (Dali::DaliException e) {
94005       {
94006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94007       };
94008     } catch (...) {
94009       {
94010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94011       };
94012     }
94013   }
94014
94015 }
94016
94017
94018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94019   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94020   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94021
94022   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94023   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94024   if (!arg2) {
94025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94026     return ;
94027   }
94028   {
94029     try {
94030       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94031     } catch (std::out_of_range& e) {
94032       {
94033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94034       };
94035     } catch (std::exception& e) {
94036       {
94037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94038       };
94039     } catch (Dali::DaliException e) {
94040       {
94041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94042       };
94043     } catch (...) {
94044       {
94045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94046       };
94047     }
94048   }
94049
94050 }
94051
94052
94053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94054   unsigned long jresult ;
94055   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94056   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94057
94058   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94059   {
94060     try {
94061       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94062     } catch (std::out_of_range& e) {
94063       {
94064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94065       };
94066     } catch (std::exception& e) {
94067       {
94068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94069       };
94070     } catch (Dali::DaliException e) {
94071       {
94072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94073       };
94074     } catch (...) {
94075       {
94076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94077       };
94078     }
94079   }
94080
94081   jresult = (unsigned long)result;
94082   return jresult;
94083 }
94084
94085
94086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94087   unsigned long jresult ;
94088   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94089   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94090
94091   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94092   {
94093     try {
94094       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94095     } catch (std::out_of_range& e) {
94096       {
94097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94098       };
94099     } catch (std::exception& e) {
94100       {
94101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94102       };
94103     } catch (Dali::DaliException e) {
94104       {
94105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94106       };
94107     } catch (...) {
94108       {
94109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94110       };
94111     }
94112   }
94113
94114   jresult = (unsigned long)result;
94115   return jresult;
94116 }
94117
94118
94119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94120   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94121   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94122
94123   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94124   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94125   {
94126     try {
94127       (arg1)->reserve(arg2);
94128     } catch (std::out_of_range& e) {
94129       {
94130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94131       };
94132     } catch (std::exception& e) {
94133       {
94134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94135       };
94136     } catch (Dali::DaliException e) {
94137       {
94138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94139       };
94140     } catch (...) {
94141       {
94142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94143       };
94144     }
94145   }
94146
94147 }
94148
94149
94150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94151   void * jresult ;
94152   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94153
94154   {
94155     try {
94156       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94157     } catch (std::out_of_range& e) {
94158       {
94159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94160       };
94161     } catch (std::exception& e) {
94162       {
94163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94164       };
94165     } catch (Dali::DaliException e) {
94166       {
94167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94168       };
94169     } catch (...) {
94170       {
94171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94172       };
94173     }
94174   }
94175
94176   jresult = (void *)result;
94177   return jresult;
94178 }
94179
94180
94181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94182   void * jresult ;
94183   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94184   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94185
94186   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94187   if (!arg1) {
94188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94189     return 0;
94190   }
94191   {
94192     try {
94193       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);
94194     } catch (std::out_of_range& e) {
94195       {
94196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94197       };
94198     } catch (std::exception& e) {
94199       {
94200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94201       };
94202     } catch (Dali::DaliException e) {
94203       {
94204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94205       };
94206     } catch (...) {
94207       {
94208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94209       };
94210     }
94211   }
94212
94213   jresult = (void *)result;
94214   return jresult;
94215 }
94216
94217
94218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94219   void * jresult ;
94220   int arg1 ;
94221   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94222
94223   arg1 = (int)jarg1;
94224   {
94225     try {
94226       try {
94227         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);
94228       }
94229       catch(std::out_of_range &_e) {
94230         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94231         return 0;
94232       }
94233
94234     } catch (std::out_of_range& e) {
94235       {
94236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94237       };
94238     } catch (std::exception& e) {
94239       {
94240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94241       };
94242     } catch (Dali::DaliException e) {
94243       {
94244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94245       };
94246     } catch (...) {
94247       {
94248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94249       };
94250     }
94251   }
94252
94253   jresult = (void *)result;
94254   return jresult;
94255 }
94256
94257
94258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94259   void * jresult ;
94260   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94261   int arg2 ;
94262   std::pair< unsigned int,Dali::Actor > result;
94263
94264   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94265   arg2 = (int)jarg2;
94266   {
94267     try {
94268       try {
94269         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94270       }
94271       catch(std::out_of_range &_e) {
94272         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94273         return 0;
94274       }
94275
94276     } catch (std::out_of_range& e) {
94277       {
94278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94279       };
94280     } catch (std::exception& e) {
94281       {
94282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94283       };
94284     } catch (Dali::DaliException e) {
94285       {
94286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94287       };
94288     } catch (...) {
94289       {
94290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94291       };
94292     }
94293   }
94294
94295   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94296   return jresult;
94297 }
94298
94299
94300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94301   void * jresult ;
94302   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94303   int arg2 ;
94304   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94305
94306   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94307   arg2 = (int)jarg2;
94308   {
94309     try {
94310       try {
94311         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94312       }
94313       catch(std::out_of_range &_e) {
94314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94315         return 0;
94316       }
94317
94318     } catch (std::out_of_range& e) {
94319       {
94320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94321       };
94322     } catch (std::exception& e) {
94323       {
94324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94325       };
94326     } catch (Dali::DaliException e) {
94327       {
94328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94329       };
94330     } catch (...) {
94331       {
94332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94333       };
94334     }
94335   }
94336
94337   jresult = (void *)result;
94338   return jresult;
94339 }
94340
94341
94342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94343   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94344   int arg2 ;
94345   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94346
94347   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94348   arg2 = (int)jarg2;
94349   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94350   if (!arg3) {
94351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94352     return ;
94353   }
94354   {
94355     try {
94356       try {
94357         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);
94358       }
94359       catch(std::out_of_range &_e) {
94360         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94361         return ;
94362       }
94363
94364     } catch (std::out_of_range& e) {
94365       {
94366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94367       };
94368     } catch (std::exception& e) {
94369       {
94370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94371       };
94372     } catch (Dali::DaliException e) {
94373       {
94374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94375       };
94376     } catch (...) {
94377       {
94378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94379       };
94380     }
94381   }
94382
94383 }
94384
94385
94386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94387   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94388   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94389
94390   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94391   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94392   if (!arg2) {
94393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94394     return ;
94395   }
94396   {
94397     try {
94398       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);
94399     } catch (std::out_of_range& e) {
94400       {
94401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94402       };
94403     } catch (std::exception& e) {
94404       {
94405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94406       };
94407     } catch (Dali::DaliException e) {
94408       {
94409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94410       };
94411     } catch (...) {
94412       {
94413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94414       };
94415     }
94416   }
94417
94418 }
94419
94420
94421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94422   void * jresult ;
94423   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94424   int arg2 ;
94425   int arg3 ;
94426   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94427
94428   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94429   arg2 = (int)jarg2;
94430   arg3 = (int)jarg3;
94431   {
94432     try {
94433       try {
94434         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);
94435       }
94436       catch(std::out_of_range &_e) {
94437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94438         return 0;
94439       }
94440       catch(std::invalid_argument &_e) {
94441         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94442         return 0;
94443       }
94444
94445     } catch (std::out_of_range& e) {
94446       {
94447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94448       };
94449     } catch (std::exception& e) {
94450       {
94451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94452       };
94453     } catch (Dali::DaliException e) {
94454       {
94455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94456       };
94457     } catch (...) {
94458       {
94459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94460       };
94461     }
94462   }
94463
94464   jresult = (void *)result;
94465   return jresult;
94466 }
94467
94468
94469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94470   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94471   int arg2 ;
94472   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94473
94474   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94475   arg2 = (int)jarg2;
94476   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94477   if (!arg3) {
94478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94479     return ;
94480   }
94481   {
94482     try {
94483       try {
94484         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);
94485       }
94486       catch(std::out_of_range &_e) {
94487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94488         return ;
94489       }
94490
94491     } catch (std::out_of_range& e) {
94492       {
94493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94494       };
94495     } catch (std::exception& e) {
94496       {
94497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94498       };
94499     } catch (Dali::DaliException e) {
94500       {
94501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94502       };
94503     } catch (...) {
94504       {
94505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94506       };
94507     }
94508   }
94509
94510 }
94511
94512
94513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94514   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94515   int arg2 ;
94516   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94517
94518   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94519   arg2 = (int)jarg2;
94520   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94521   if (!arg3) {
94522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94523     return ;
94524   }
94525   {
94526     try {
94527       try {
94528         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);
94529       }
94530       catch(std::out_of_range &_e) {
94531         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94532         return ;
94533       }
94534
94535     } catch (std::out_of_range& e) {
94536       {
94537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94538       };
94539     } catch (std::exception& e) {
94540       {
94541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94542       };
94543     } catch (Dali::DaliException e) {
94544       {
94545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94546       };
94547     } catch (...) {
94548       {
94549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94550       };
94551     }
94552   }
94553
94554 }
94555
94556
94557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94558   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94559   int arg2 ;
94560
94561   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94562   arg2 = (int)jarg2;
94563   {
94564     try {
94565       try {
94566         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94567       }
94568       catch(std::out_of_range &_e) {
94569         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94570         return ;
94571       }
94572
94573     } catch (std::out_of_range& e) {
94574       {
94575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94576       };
94577     } catch (std::exception& e) {
94578       {
94579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94580       };
94581     } catch (Dali::DaliException e) {
94582       {
94583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94584       };
94585     } catch (...) {
94586       {
94587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94588       };
94589     }
94590   }
94591
94592 }
94593
94594
94595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94596   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94597   int arg2 ;
94598   int arg3 ;
94599
94600   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94601   arg2 = (int)jarg2;
94602   arg3 = (int)jarg3;
94603   {
94604     try {
94605       try {
94606         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94607       }
94608       catch(std::out_of_range &_e) {
94609         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94610         return ;
94611       }
94612       catch(std::invalid_argument &_e) {
94613         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94614         return ;
94615       }
94616
94617     } catch (std::out_of_range& e) {
94618       {
94619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94620       };
94621     } catch (std::exception& e) {
94622       {
94623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94624       };
94625     } catch (Dali::DaliException e) {
94626       {
94627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94628       };
94629     } catch (...) {
94630       {
94631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94632       };
94633     }
94634   }
94635
94636 }
94637
94638
94639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94640   void * jresult ;
94641   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94642   int arg2 ;
94643   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94644
94645   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94646   if (!arg1) {
94647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94648     return 0;
94649   }
94650   arg2 = (int)jarg2;
94651   {
94652     try {
94653       try {
94654         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);
94655       }
94656       catch(std::out_of_range &_e) {
94657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94658         return 0;
94659       }
94660
94661     } catch (std::out_of_range& e) {
94662       {
94663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94664       };
94665     } catch (std::exception& e) {
94666       {
94667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94668       };
94669     } catch (Dali::DaliException e) {
94670       {
94671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94672       };
94673     } catch (...) {
94674       {
94675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94676       };
94677     }
94678   }
94679
94680   jresult = (void *)result;
94681   return jresult;
94682 }
94683
94684
94685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94686   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94687
94688   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94689   {
94690     try {
94691       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94692     } catch (std::out_of_range& e) {
94693       {
94694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94695       };
94696     } catch (std::exception& e) {
94697       {
94698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94699       };
94700     } catch (Dali::DaliException e) {
94701       {
94702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94703       };
94704     } catch (...) {
94705       {
94706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94707       };
94708     }
94709   }
94710
94711 }
94712
94713
94714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94715   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94716   int arg2 ;
94717   int arg3 ;
94718
94719   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94720   arg2 = (int)jarg2;
94721   arg3 = (int)jarg3;
94722   {
94723     try {
94724       try {
94725         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94726       }
94727       catch(std::out_of_range &_e) {
94728         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94729         return ;
94730       }
94731       catch(std::invalid_argument &_e) {
94732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94733         return ;
94734       }
94735
94736     } catch (std::out_of_range& e) {
94737       {
94738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94739       };
94740     } catch (std::exception& e) {
94741       {
94742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94743       };
94744     } catch (Dali::DaliException e) {
94745       {
94746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94747       };
94748     } catch (...) {
94749       {
94750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94751       };
94752     }
94753   }
94754
94755 }
94756
94757
94758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94759   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94760   int arg2 ;
94761   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94762
94763   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94764   arg2 = (int)jarg2;
94765   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94766   if (!arg3) {
94767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94768     return ;
94769   }
94770   {
94771     try {
94772       try {
94773         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);
94774       }
94775       catch(std::out_of_range &_e) {
94776         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94777         return ;
94778       }
94779
94780     } catch (std::out_of_range& e) {
94781       {
94782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94783       };
94784     } catch (std::exception& e) {
94785       {
94786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94787       };
94788     } catch (Dali::DaliException e) {
94789       {
94790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94791       };
94792     } catch (...) {
94793       {
94794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94795       };
94796     }
94797   }
94798
94799 }
94800
94801
94802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94803   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94804
94805   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94806   {
94807     try {
94808       delete arg1;
94809     } catch (std::out_of_range& e) {
94810       {
94811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94812       };
94813     } catch (std::exception& e) {
94814       {
94815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94816       };
94817     } catch (Dali::DaliException e) {
94818       {
94819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94820       };
94821     } catch (...) {
94822       {
94823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94824       };
94825     }
94826   }
94827
94828 }
94829
94830
94831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94832   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94833
94834   arg1 = (std::vector< Dali::Actor > *)jarg1;
94835   {
94836     try {
94837       (arg1)->clear();
94838     } catch (std::out_of_range& e) {
94839       {
94840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94841       };
94842     } catch (std::exception& e) {
94843       {
94844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94845       };
94846     } catch (Dali::DaliException e) {
94847       {
94848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94849       };
94850     } catch (...) {
94851       {
94852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94853       };
94854     }
94855   }
94856
94857 }
94858
94859
94860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94861   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94862   Dali::Actor *arg2 = 0 ;
94863
94864   arg1 = (std::vector< Dali::Actor > *)jarg1;
94865   arg2 = (Dali::Actor *)jarg2;
94866   if (!arg2) {
94867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94868     return ;
94869   }
94870   {
94871     try {
94872       (arg1)->push_back((Dali::Actor const &)*arg2);
94873     } catch (std::out_of_range& e) {
94874       {
94875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94876       };
94877     } catch (std::exception& e) {
94878       {
94879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94880       };
94881     } catch (Dali::DaliException e) {
94882       {
94883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94884       };
94885     } catch (...) {
94886       {
94887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94888       };
94889     }
94890   }
94891
94892 }
94893
94894
94895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94896   unsigned long jresult ;
94897   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94898   std::vector< Dali::Actor >::size_type result;
94899
94900   arg1 = (std::vector< Dali::Actor > *)jarg1;
94901   {
94902     try {
94903       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94904     } catch (std::out_of_range& e) {
94905       {
94906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94907       };
94908     } catch (std::exception& e) {
94909       {
94910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94911       };
94912     } catch (Dali::DaliException e) {
94913       {
94914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94915       };
94916     } catch (...) {
94917       {
94918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94919       };
94920     }
94921   }
94922
94923   jresult = (unsigned long)result;
94924   return jresult;
94925 }
94926
94927
94928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94929   unsigned long jresult ;
94930   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94931   std::vector< Dali::Actor >::size_type result;
94932
94933   arg1 = (std::vector< Dali::Actor > *)jarg1;
94934   {
94935     try {
94936       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94937     } catch (std::out_of_range& e) {
94938       {
94939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94940       };
94941     } catch (std::exception& e) {
94942       {
94943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94944       };
94945     } catch (Dali::DaliException e) {
94946       {
94947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94948       };
94949     } catch (...) {
94950       {
94951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94952       };
94953     }
94954   }
94955
94956   jresult = (unsigned long)result;
94957   return jresult;
94958 }
94959
94960
94961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94962   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94963   std::vector< Dali::Actor >::size_type arg2 ;
94964
94965   arg1 = (std::vector< Dali::Actor > *)jarg1;
94966   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94967   {
94968     try {
94969       (arg1)->reserve(arg2);
94970     } catch (std::out_of_range& e) {
94971       {
94972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94973       };
94974     } catch (std::exception& e) {
94975       {
94976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94977       };
94978     } catch (Dali::DaliException e) {
94979       {
94980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94981       };
94982     } catch (...) {
94983       {
94984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94985       };
94986     }
94987   }
94988
94989 }
94990
94991
94992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94993   void * jresult ;
94994   std::vector< Dali::Actor > *result = 0 ;
94995
94996   {
94997     try {
94998       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94999     } catch (std::out_of_range& e) {
95000       {
95001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95002       };
95003     } catch (std::exception& e) {
95004       {
95005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95006       };
95007     } catch (Dali::DaliException e) {
95008       {
95009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95010       };
95011     } catch (...) {
95012       {
95013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95014       };
95015     }
95016   }
95017
95018   jresult = (void *)result;
95019   return jresult;
95020 }
95021
95022
95023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95024   void * jresult ;
95025   std::vector< Dali::Actor > *arg1 = 0 ;
95026   std::vector< Dali::Actor > *result = 0 ;
95027
95028   arg1 = (std::vector< Dali::Actor > *)jarg1;
95029   if (!arg1) {
95030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95031     return 0;
95032   }
95033   {
95034     try {
95035       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95036     } catch (std::out_of_range& e) {
95037       {
95038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95039       };
95040     } catch (std::exception& e) {
95041       {
95042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95043       };
95044     } catch (Dali::DaliException e) {
95045       {
95046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95047       };
95048     } catch (...) {
95049       {
95050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95051       };
95052     }
95053   }
95054
95055   jresult = (void *)result;
95056   return jresult;
95057 }
95058
95059
95060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95061   void * jresult ;
95062   int arg1 ;
95063   std::vector< Dali::Actor > *result = 0 ;
95064
95065   arg1 = (int)jarg1;
95066   {
95067     try {
95068       try {
95069         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95070       }
95071       catch(std::out_of_range &_e) {
95072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95073         return 0;
95074       }
95075
95076     } catch (std::out_of_range& e) {
95077       {
95078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95079       };
95080     } catch (std::exception& e) {
95081       {
95082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95083       };
95084     } catch (Dali::DaliException e) {
95085       {
95086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95087       };
95088     } catch (...) {
95089       {
95090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95091       };
95092     }
95093   }
95094
95095   jresult = (void *)result;
95096   return jresult;
95097 }
95098
95099
95100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95101   void * jresult ;
95102   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95103   int arg2 ;
95104   Dali::Actor result;
95105
95106   arg1 = (std::vector< Dali::Actor > *)jarg1;
95107   arg2 = (int)jarg2;
95108   {
95109     try {
95110       try {
95111         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95112       }
95113       catch(std::out_of_range &_e) {
95114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95115         return 0;
95116       }
95117
95118     } catch (std::out_of_range& e) {
95119       {
95120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95121       };
95122     } catch (std::exception& e) {
95123       {
95124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95125       };
95126     } catch (Dali::DaliException e) {
95127       {
95128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95129       };
95130     } catch (...) {
95131       {
95132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95133       };
95134     }
95135   }
95136
95137   jresult = new Dali::Actor((const Dali::Actor &)result);
95138   return jresult;
95139 }
95140
95141
95142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95143   void * jresult ;
95144   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95145   int arg2 ;
95146   Dali::Actor *result = 0 ;
95147
95148   arg1 = (std::vector< Dali::Actor > *)jarg1;
95149   arg2 = (int)jarg2;
95150   {
95151     try {
95152       try {
95153         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95154       }
95155       catch(std::out_of_range &_e) {
95156         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95157         return 0;
95158       }
95159
95160     } catch (std::out_of_range& e) {
95161       {
95162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95163       };
95164     } catch (std::exception& e) {
95165       {
95166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95167       };
95168     } catch (Dali::DaliException e) {
95169       {
95170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95171       };
95172     } catch (...) {
95173       {
95174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95175       };
95176     }
95177   }
95178
95179   jresult = (void *)result;
95180   return jresult;
95181 }
95182
95183
95184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95185   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95186   int arg2 ;
95187   Dali::Actor *arg3 = 0 ;
95188
95189   arg1 = (std::vector< Dali::Actor > *)jarg1;
95190   arg2 = (int)jarg2;
95191   arg3 = (Dali::Actor *)jarg3;
95192   if (!arg3) {
95193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95194     return ;
95195   }
95196   {
95197     try {
95198       try {
95199         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95200       }
95201       catch(std::out_of_range &_e) {
95202         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95203         return ;
95204       }
95205
95206     } catch (std::out_of_range& e) {
95207       {
95208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95209       };
95210     } catch (std::exception& e) {
95211       {
95212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95213       };
95214     } catch (Dali::DaliException e) {
95215       {
95216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95217       };
95218     } catch (...) {
95219       {
95220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95221       };
95222     }
95223   }
95224
95225 }
95226
95227
95228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95229   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95230   std::vector< Dali::Actor > *arg2 = 0 ;
95231
95232   arg1 = (std::vector< Dali::Actor > *)jarg1;
95233   arg2 = (std::vector< Dali::Actor > *)jarg2;
95234   if (!arg2) {
95235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95236     return ;
95237   }
95238   {
95239     try {
95240       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95241     } catch (std::out_of_range& e) {
95242       {
95243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95244       };
95245     } catch (std::exception& e) {
95246       {
95247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95248       };
95249     } catch (Dali::DaliException e) {
95250       {
95251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95252       };
95253     } catch (...) {
95254       {
95255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95256       };
95257     }
95258   }
95259
95260 }
95261
95262
95263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95264   void * jresult ;
95265   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95266   int arg2 ;
95267   int arg3 ;
95268   std::vector< Dali::Actor > *result = 0 ;
95269
95270   arg1 = (std::vector< Dali::Actor > *)jarg1;
95271   arg2 = (int)jarg2;
95272   arg3 = (int)jarg3;
95273   {
95274     try {
95275       try {
95276         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95277       }
95278       catch(std::out_of_range &_e) {
95279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95280         return 0;
95281       }
95282       catch(std::invalid_argument &_e) {
95283         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95284         return 0;
95285       }
95286
95287     } catch (std::out_of_range& e) {
95288       {
95289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95290       };
95291     } catch (std::exception& e) {
95292       {
95293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95294       };
95295     } catch (Dali::DaliException e) {
95296       {
95297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95298       };
95299     } catch (...) {
95300       {
95301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95302       };
95303     }
95304   }
95305
95306   jresult = (void *)result;
95307   return jresult;
95308 }
95309
95310
95311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95312   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95313   int arg2 ;
95314   Dali::Actor *arg3 = 0 ;
95315
95316   arg1 = (std::vector< Dali::Actor > *)jarg1;
95317   arg2 = (int)jarg2;
95318   arg3 = (Dali::Actor *)jarg3;
95319   if (!arg3) {
95320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95321     return ;
95322   }
95323   {
95324     try {
95325       try {
95326         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95327       }
95328       catch(std::out_of_range &_e) {
95329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95330         return ;
95331       }
95332
95333     } catch (std::out_of_range& e) {
95334       {
95335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95336       };
95337     } catch (std::exception& e) {
95338       {
95339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95340       };
95341     } catch (Dali::DaliException e) {
95342       {
95343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95344       };
95345     } catch (...) {
95346       {
95347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95348       };
95349     }
95350   }
95351
95352 }
95353
95354
95355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95356   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95357   int arg2 ;
95358   std::vector< Dali::Actor > *arg3 = 0 ;
95359
95360   arg1 = (std::vector< Dali::Actor > *)jarg1;
95361   arg2 = (int)jarg2;
95362   arg3 = (std::vector< Dali::Actor > *)jarg3;
95363   if (!arg3) {
95364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95365     return ;
95366   }
95367   {
95368     try {
95369       try {
95370         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95371       }
95372       catch(std::out_of_range &_e) {
95373         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95374         return ;
95375       }
95376
95377     } catch (std::out_of_range& e) {
95378       {
95379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95380       };
95381     } catch (std::exception& e) {
95382       {
95383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95384       };
95385     } catch (Dali::DaliException e) {
95386       {
95387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95388       };
95389     } catch (...) {
95390       {
95391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95392       };
95393     }
95394   }
95395
95396 }
95397
95398
95399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95400   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95401   int arg2 ;
95402
95403   arg1 = (std::vector< Dali::Actor > *)jarg1;
95404   arg2 = (int)jarg2;
95405   {
95406     try {
95407       try {
95408         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95409       }
95410       catch(std::out_of_range &_e) {
95411         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95412         return ;
95413       }
95414
95415     } catch (std::out_of_range& e) {
95416       {
95417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95418       };
95419     } catch (std::exception& e) {
95420       {
95421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95422       };
95423     } catch (Dali::DaliException e) {
95424       {
95425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95426       };
95427     } catch (...) {
95428       {
95429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95430       };
95431     }
95432   }
95433
95434 }
95435
95436
95437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95438   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95439   int arg2 ;
95440   int arg3 ;
95441
95442   arg1 = (std::vector< Dali::Actor > *)jarg1;
95443   arg2 = (int)jarg2;
95444   arg3 = (int)jarg3;
95445   {
95446     try {
95447       try {
95448         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95449       }
95450       catch(std::out_of_range &_e) {
95451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95452         return ;
95453       }
95454       catch(std::invalid_argument &_e) {
95455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95456         return ;
95457       }
95458
95459     } catch (std::out_of_range& e) {
95460       {
95461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95462       };
95463     } catch (std::exception& e) {
95464       {
95465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95466       };
95467     } catch (Dali::DaliException e) {
95468       {
95469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95470       };
95471     } catch (...) {
95472       {
95473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95474       };
95475     }
95476   }
95477
95478 }
95479
95480
95481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95482   void * jresult ;
95483   Dali::Actor *arg1 = 0 ;
95484   int arg2 ;
95485   std::vector< Dali::Actor > *result = 0 ;
95486
95487   arg1 = (Dali::Actor *)jarg1;
95488   if (!arg1) {
95489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95490     return 0;
95491   }
95492   arg2 = (int)jarg2;
95493   {
95494     try {
95495       try {
95496         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95497       }
95498       catch(std::out_of_range &_e) {
95499         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95500         return 0;
95501       }
95502
95503     } catch (std::out_of_range& e) {
95504       {
95505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95506       };
95507     } catch (std::exception& e) {
95508       {
95509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95510       };
95511     } catch (Dali::DaliException e) {
95512       {
95513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95514       };
95515     } catch (...) {
95516       {
95517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95518       };
95519     }
95520   }
95521
95522   jresult = (void *)result;
95523   return jresult;
95524 }
95525
95526
95527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95528   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95529
95530   arg1 = (std::vector< Dali::Actor > *)jarg1;
95531   {
95532     try {
95533       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95534     } catch (std::out_of_range& e) {
95535       {
95536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95537       };
95538     } catch (std::exception& e) {
95539       {
95540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95541       };
95542     } catch (Dali::DaliException e) {
95543       {
95544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95545       };
95546     } catch (...) {
95547       {
95548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95549       };
95550     }
95551   }
95552
95553 }
95554
95555
95556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95557   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95558   int arg2 ;
95559   int arg3 ;
95560
95561   arg1 = (std::vector< Dali::Actor > *)jarg1;
95562   arg2 = (int)jarg2;
95563   arg3 = (int)jarg3;
95564   {
95565     try {
95566       try {
95567         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95568       }
95569       catch(std::out_of_range &_e) {
95570         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95571         return ;
95572       }
95573       catch(std::invalid_argument &_e) {
95574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95575         return ;
95576       }
95577
95578     } catch (std::out_of_range& e) {
95579       {
95580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95581       };
95582     } catch (std::exception& e) {
95583       {
95584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95585       };
95586     } catch (Dali::DaliException e) {
95587       {
95588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95589       };
95590     } catch (...) {
95591       {
95592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95593       };
95594     }
95595   }
95596
95597 }
95598
95599
95600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95601   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95602   int arg2 ;
95603   std::vector< Dali::Actor > *arg3 = 0 ;
95604
95605   arg1 = (std::vector< Dali::Actor > *)jarg1;
95606   arg2 = (int)jarg2;
95607   arg3 = (std::vector< Dali::Actor > *)jarg3;
95608   if (!arg3) {
95609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95610     return ;
95611   }
95612   {
95613     try {
95614       try {
95615         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95616       }
95617       catch(std::out_of_range &_e) {
95618         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95619         return ;
95620       }
95621
95622     } catch (std::out_of_range& e) {
95623       {
95624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95625       };
95626     } catch (std::exception& e) {
95627       {
95628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95629       };
95630     } catch (Dali::DaliException e) {
95631       {
95632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95633       };
95634     } catch (...) {
95635       {
95636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95637       };
95638     }
95639   }
95640
95641 }
95642
95643
95644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95645   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95646
95647   arg1 = (std::vector< Dali::Actor > *)jarg1;
95648   {
95649     try {
95650       delete arg1;
95651     } catch (std::out_of_range& e) {
95652       {
95653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95654       };
95655     } catch (std::exception& e) {
95656       {
95657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95658       };
95659     } catch (Dali::DaliException e) {
95660       {
95661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95662       };
95663     } catch (...) {
95664       {
95665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95666       };
95667     }
95668   }
95669
95670 }
95671
95672
95673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95674   unsigned int jresult ;
95675   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95676   bool result;
95677
95678   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95679   {
95680     try {
95681       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95682     } catch (std::out_of_range& e) {
95683       {
95684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95685       };
95686     } catch (std::exception& e) {
95687       {
95688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95689       };
95690     } catch (Dali::DaliException e) {
95691       {
95692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95693       };
95694     } catch (...) {
95695       {
95696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95697       };
95698     }
95699   }
95700
95701   jresult = result;
95702   return jresult;
95703 }
95704
95705
95706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95707   unsigned long jresult ;
95708   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95709   std::size_t result;
95710
95711   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95712   {
95713     try {
95714       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95715     } catch (std::out_of_range& e) {
95716       {
95717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95718       };
95719     } catch (std::exception& e) {
95720       {
95721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95722       };
95723     } catch (Dali::DaliException e) {
95724       {
95725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95726       };
95727     } catch (...) {
95728       {
95729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95730       };
95731     }
95732   }
95733
95734   jresult = (unsigned long)result;
95735   return jresult;
95736 }
95737
95738
95739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95740   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95741   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95742
95743   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95744   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95745   {
95746     try {
95747       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95748     } catch (std::out_of_range& e) {
95749       {
95750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95751       };
95752     } catch (std::exception& e) {
95753       {
95754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95755       };
95756     } catch (Dali::DaliException e) {
95757       {
95758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95759       };
95760     } catch (...) {
95761       {
95762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95763       };
95764     }
95765   }
95766
95767 }
95768
95769
95770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95771   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95772   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95773
95774   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95775   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95776   {
95777     try {
95778       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95779     } catch (std::out_of_range& e) {
95780       {
95781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95782       };
95783     } catch (std::exception& e) {
95784       {
95785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95786       };
95787     } catch (Dali::DaliException e) {
95788       {
95789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95790       };
95791     } catch (...) {
95792       {
95793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95794       };
95795     }
95796   }
95797
95798 }
95799
95800
95801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95802   unsigned int jresult ;
95803   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95804   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95805   bool result;
95806
95807   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95808   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95809   if (!arg2) {
95810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95811     return 0;
95812   }
95813   {
95814     try {
95815       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95816     } catch (std::out_of_range& e) {
95817       {
95818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95819       };
95820     } catch (std::exception& e) {
95821       {
95822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95823       };
95824     } catch (Dali::DaliException e) {
95825       {
95826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95827       };
95828     } catch (...) {
95829       {
95830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95831       };
95832     }
95833   }
95834
95835   jresult = result;
95836   return jresult;
95837 }
95838
95839
95840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95841   void * jresult ;
95842   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95843
95844   {
95845     try {
95846       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95847     } catch (std::out_of_range& e) {
95848       {
95849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95850       };
95851     } catch (std::exception& e) {
95852       {
95853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95854       };
95855     } catch (Dali::DaliException e) {
95856       {
95857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95858       };
95859     } catch (...) {
95860       {
95861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95862       };
95863     }
95864   }
95865
95866   jresult = (void *)result;
95867   return jresult;
95868 }
95869
95870
95871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95872   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95873
95874   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95875   {
95876     try {
95877       delete arg1;
95878     } catch (std::out_of_range& e) {
95879       {
95880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95881       };
95882     } catch (std::exception& e) {
95883       {
95884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95885       };
95886     } catch (Dali::DaliException e) {
95887       {
95888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95889       };
95890     } catch (...) {
95891       {
95892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95893       };
95894     }
95895   }
95896
95897 }
95898
95899
95900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95901   unsigned int jresult ;
95902   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95903   bool result;
95904
95905   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95906   {
95907     try {
95908       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);
95909     } catch (std::out_of_range& e) {
95910       {
95911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95912       };
95913     } catch (std::exception& e) {
95914       {
95915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95916       };
95917     } catch (Dali::DaliException e) {
95918       {
95919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95920       };
95921     } catch (...) {
95922       {
95923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95924       };
95925     }
95926   }
95927
95928   jresult = result;
95929   return jresult;
95930 }
95931
95932
95933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95934   unsigned long jresult ;
95935   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95936   std::size_t result;
95937
95938   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95939   {
95940     try {
95941       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);
95942     } catch (std::out_of_range& e) {
95943       {
95944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95945       };
95946     } catch (std::exception& e) {
95947       {
95948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95949       };
95950     } catch (Dali::DaliException e) {
95951       {
95952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95953       };
95954     } catch (...) {
95955       {
95956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95957       };
95958     }
95959   }
95960
95961   jresult = (unsigned long)result;
95962   return jresult;
95963 }
95964
95965
95966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95967   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95968   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95969
95970   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95971   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95972   {
95973     try {
95974       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95975     } catch (std::out_of_range& e) {
95976       {
95977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95978       };
95979     } catch (std::exception& e) {
95980       {
95981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95982       };
95983     } catch (Dali::DaliException e) {
95984       {
95985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95986       };
95987     } catch (...) {
95988       {
95989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95990       };
95991     }
95992   }
95993
95994 }
95995
95996
95997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95998   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95999   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96000
96001   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96002   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96003   {
96004     try {
96005       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96006     } catch (std::out_of_range& e) {
96007       {
96008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96009       };
96010     } catch (std::exception& e) {
96011       {
96012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96013       };
96014     } catch (Dali::DaliException e) {
96015       {
96016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96017       };
96018     } catch (...) {
96019       {
96020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96021       };
96022     }
96023   }
96024
96025 }
96026
96027
96028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96029   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96030   Dali::Actor arg2 ;
96031   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96032   Dali::Actor *argp2 ;
96033
96034   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96035   argp2 = (Dali::Actor *)jarg2;
96036   if (!argp2) {
96037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96038     return ;
96039   }
96040   arg2 = *argp2;
96041   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96042   {
96043     try {
96044       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96045     } catch (std::out_of_range& e) {
96046       {
96047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96048       };
96049     } catch (std::exception& e) {
96050       {
96051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96052       };
96053     } catch (Dali::DaliException e) {
96054       {
96055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96056       };
96057     } catch (...) {
96058       {
96059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96060       };
96061     }
96062   }
96063
96064 }
96065
96066
96067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96068   void * jresult ;
96069   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96070
96071   {
96072     try {
96073       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96074     } catch (std::out_of_range& e) {
96075       {
96076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96077       };
96078     } catch (std::exception& e) {
96079       {
96080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96081       };
96082     } catch (Dali::DaliException e) {
96083       {
96084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96085       };
96086     } catch (...) {
96087       {
96088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96089       };
96090     }
96091   }
96092
96093   jresult = (void *)result;
96094   return jresult;
96095 }
96096
96097
96098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96099   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96100
96101   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96102   {
96103     try {
96104       delete arg1;
96105     } catch (std::out_of_range& e) {
96106       {
96107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96108       };
96109     } catch (std::exception& e) {
96110       {
96111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96112       };
96113     } catch (Dali::DaliException e) {
96114       {
96115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96116       };
96117     } catch (...) {
96118       {
96119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96120       };
96121     }
96122   }
96123
96124 }
96125
96126
96127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96128   unsigned int jresult ;
96129   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96130   bool result;
96131
96132   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96133   {
96134     try {
96135       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96136     } catch (std::out_of_range& e) {
96137       {
96138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96139       };
96140     } catch (std::exception& e) {
96141       {
96142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96143       };
96144     } catch (Dali::DaliException e) {
96145       {
96146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96147       };
96148     } catch (...) {
96149       {
96150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96151       };
96152     }
96153   }
96154
96155   jresult = result;
96156   return jresult;
96157 }
96158
96159
96160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96161   unsigned long jresult ;
96162   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96163   std::size_t result;
96164
96165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96166   {
96167     try {
96168       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96169     } catch (std::out_of_range& e) {
96170       {
96171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96172       };
96173     } catch (std::exception& e) {
96174       {
96175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96176       };
96177     } catch (Dali::DaliException e) {
96178       {
96179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96180       };
96181     } catch (...) {
96182       {
96183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96184       };
96185     }
96186   }
96187
96188   jresult = (unsigned long)result;
96189   return jresult;
96190 }
96191
96192
96193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96194   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96195   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96196
96197   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96198   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96199   {
96200     try {
96201       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96202     } catch (std::out_of_range& e) {
96203       {
96204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96205       };
96206     } catch (std::exception& e) {
96207       {
96208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96209       };
96210     } catch (Dali::DaliException e) {
96211       {
96212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96213       };
96214     } catch (...) {
96215       {
96216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96217       };
96218     }
96219   }
96220
96221 }
96222
96223
96224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96225   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96226   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96227
96228   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96229   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96230   {
96231     try {
96232       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96233     } catch (std::out_of_range& e) {
96234       {
96235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96236       };
96237     } catch (std::exception& e) {
96238       {
96239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96240       };
96241     } catch (Dali::DaliException e) {
96242       {
96243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96244       };
96245     } catch (...) {
96246       {
96247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96248       };
96249     }
96250   }
96251
96252 }
96253
96254
96255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96256   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96257   Dali::Actor arg2 ;
96258   Dali::Actor arg3 ;
96259   Dali::Actor *argp2 ;
96260   Dali::Actor *argp3 ;
96261
96262   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96263   argp2 = (Dali::Actor *)jarg2;
96264   if (!argp2) {
96265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96266     return ;
96267   }
96268   arg2 = *argp2;
96269   argp3 = (Dali::Actor *)jarg3;
96270   if (!argp3) {
96271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96272     return ;
96273   }
96274   arg3 = *argp3;
96275   {
96276     try {
96277       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96278     } catch (std::out_of_range& e) {
96279       {
96280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96281       };
96282     } catch (std::exception& e) {
96283       {
96284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96285       };
96286     } catch (Dali::DaliException e) {
96287       {
96288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96289       };
96290     } catch (...) {
96291       {
96292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96293       };
96294     }
96295   }
96296
96297 }
96298
96299
96300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96301   void * jresult ;
96302   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96303
96304   {
96305     try {
96306       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96307     } catch (std::out_of_range& e) {
96308       {
96309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96310       };
96311     } catch (std::exception& e) {
96312       {
96313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96314       };
96315     } catch (Dali::DaliException e) {
96316       {
96317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96318       };
96319     } catch (...) {
96320       {
96321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96322       };
96323     }
96324   }
96325
96326   jresult = (void *)result;
96327   return jresult;
96328 }
96329
96330
96331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96332   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96333
96334   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96335   {
96336     try {
96337       delete arg1;
96338     } catch (std::out_of_range& e) {
96339       {
96340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96341       };
96342     } catch (std::exception& e) {
96343       {
96344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96345       };
96346     } catch (Dali::DaliException e) {
96347       {
96348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96349       };
96350     } catch (...) {
96351       {
96352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96353       };
96354     }
96355   }
96356
96357 }
96358
96359
96360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96361   unsigned int jresult ;
96362   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96363   bool result;
96364
96365   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96366   {
96367     try {
96368       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96369     } catch (std::out_of_range& e) {
96370       {
96371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96372       };
96373     } catch (std::exception& e) {
96374       {
96375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96376       };
96377     } catch (Dali::DaliException e) {
96378       {
96379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96380       };
96381     } catch (...) {
96382       {
96383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96384       };
96385     }
96386   }
96387
96388   jresult = result;
96389   return jresult;
96390 }
96391
96392
96393 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96394   unsigned long jresult ;
96395   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96396   std::size_t result;
96397
96398   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96399   {
96400     try {
96401       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96402     } catch (std::out_of_range& e) {
96403       {
96404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96405       };
96406     } catch (std::exception& e) {
96407       {
96408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96409       };
96410     } catch (Dali::DaliException e) {
96411       {
96412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96413       };
96414     } catch (...) {
96415       {
96416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96417       };
96418     }
96419   }
96420
96421   jresult = (unsigned long)result;
96422   return jresult;
96423 }
96424
96425
96426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96427   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96428   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96429
96430   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96431   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96432   {
96433     try {
96434       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96435     } catch (std::out_of_range& e) {
96436       {
96437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96438       };
96439     } catch (std::exception& e) {
96440       {
96441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96442       };
96443     } catch (Dali::DaliException e) {
96444       {
96445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96446       };
96447     } catch (...) {
96448       {
96449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96450       };
96451     }
96452   }
96453
96454 }
96455
96456
96457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96458   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96459   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96460
96461   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96462   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96463   {
96464     try {
96465       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96466     } catch (std::out_of_range& e) {
96467       {
96468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96469       };
96470     } catch (std::exception& e) {
96471       {
96472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96473       };
96474     } catch (Dali::DaliException e) {
96475       {
96476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96477       };
96478     } catch (...) {
96479       {
96480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96481       };
96482     }
96483   }
96484
96485 }
96486
96487
96488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96489   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96490   Dali::Actor arg2 ;
96491   bool arg3 ;
96492   Dali::Actor *argp2 ;
96493
96494   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96495   argp2 = (Dali::Actor *)jarg2;
96496   if (!argp2) {
96497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96498     return ;
96499   }
96500   arg2 = *argp2;
96501   arg3 = jarg3 ? true : false;
96502   {
96503     try {
96504       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96505     } catch (std::out_of_range& e) {
96506       {
96507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96508       };
96509     } catch (std::exception& e) {
96510       {
96511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96512       };
96513     } catch (Dali::DaliException e) {
96514       {
96515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96516       };
96517     } catch (...) {
96518       {
96519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96520       };
96521     }
96522   }
96523
96524 }
96525
96526
96527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96528   void * jresult ;
96529   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96530
96531   {
96532     try {
96533       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96534     } catch (std::out_of_range& e) {
96535       {
96536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96537       };
96538     } catch (std::exception& e) {
96539       {
96540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96541       };
96542     } catch (Dali::DaliException e) {
96543       {
96544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96545       };
96546     } catch (...) {
96547       {
96548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96549       };
96550     }
96551   }
96552
96553   jresult = (void *)result;
96554   return jresult;
96555 }
96556
96557
96558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96559   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96560
96561   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96562   {
96563     try {
96564       delete arg1;
96565     } catch (std::out_of_range& e) {
96566       {
96567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96568       };
96569     } catch (std::exception& e) {
96570       {
96571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96572       };
96573     } catch (Dali::DaliException e) {
96574       {
96575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96576       };
96577     } catch (...) {
96578       {
96579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96580       };
96581     }
96582   }
96583
96584 }
96585
96586
96587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96588   unsigned int jresult ;
96589   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96590   bool result;
96591
96592   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96593   {
96594     try {
96595       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);
96596     } catch (std::out_of_range& e) {
96597       {
96598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96599       };
96600     } catch (std::exception& e) {
96601       {
96602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96603       };
96604     } catch (Dali::DaliException e) {
96605       {
96606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96607       };
96608     } catch (...) {
96609       {
96610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96611       };
96612     }
96613   }
96614
96615   jresult = result;
96616   return jresult;
96617 }
96618
96619
96620 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96621   unsigned long jresult ;
96622   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96623   std::size_t result;
96624
96625   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96626   {
96627     try {
96628       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);
96629     } catch (std::out_of_range& e) {
96630       {
96631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96632       };
96633     } catch (std::exception& e) {
96634       {
96635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96636       };
96637     } catch (Dali::DaliException e) {
96638       {
96639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96640       };
96641     } catch (...) {
96642       {
96643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96644       };
96645     }
96646   }
96647
96648   jresult = (unsigned long)result;
96649   return jresult;
96650 }
96651
96652
96653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96654   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96655   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96656
96657   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96658   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96659   {
96660     try {
96661       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96662     } catch (std::out_of_range& e) {
96663       {
96664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96665       };
96666     } catch (std::exception& e) {
96667       {
96668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96669       };
96670     } catch (Dali::DaliException e) {
96671       {
96672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96673       };
96674     } catch (...) {
96675       {
96676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96677       };
96678     }
96679   }
96680
96681 }
96682
96683
96684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96685   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96686   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96687
96688   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96689   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96690   {
96691     try {
96692       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96693     } catch (std::out_of_range& e) {
96694       {
96695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96696       };
96697     } catch (std::exception& e) {
96698       {
96699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96700       };
96701     } catch (Dali::DaliException e) {
96702       {
96703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96704       };
96705     } catch (...) {
96706       {
96707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96708       };
96709     }
96710   }
96711
96712 }
96713
96714
96715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96716   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96717   Dali::Toolkit::StyleManager arg2 ;
96718   Dali::StyleChange::Type arg3 ;
96719   Dali::Toolkit::StyleManager *argp2 ;
96720
96721   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96722   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96723   if (!argp2) {
96724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96725     return ;
96726   }
96727   arg2 = *argp2;
96728   arg3 = (Dali::StyleChange::Type)jarg3;
96729   {
96730     try {
96731       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96732     } catch (std::out_of_range& e) {
96733       {
96734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96735       };
96736     } catch (std::exception& e) {
96737       {
96738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96739       };
96740     } catch (Dali::DaliException e) {
96741       {
96742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96743       };
96744     } catch (...) {
96745       {
96746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96747       };
96748     }
96749   }
96750
96751 }
96752
96753
96754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96755   void * jresult ;
96756   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96757
96758   {
96759     try {
96760       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96761     } catch (std::out_of_range& e) {
96762       {
96763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96764       };
96765     } catch (std::exception& e) {
96766       {
96767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96768       };
96769     } catch (Dali::DaliException e) {
96770       {
96771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96772       };
96773     } catch (...) {
96774       {
96775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96776       };
96777     }
96778   }
96779
96780   jresult = (void *)result;
96781   return jresult;
96782 }
96783
96784
96785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96786   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96787
96788   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96789   {
96790     try {
96791       delete arg1;
96792     } catch (std::out_of_range& e) {
96793       {
96794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96795       };
96796     } catch (std::exception& e) {
96797       {
96798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96799       };
96800     } catch (Dali::DaliException e) {
96801       {
96802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96803       };
96804     } catch (...) {
96805       {
96806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96807       };
96808     }
96809   }
96810
96811 }
96812
96813
96814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96815   unsigned int jresult ;
96816   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96817   bool result;
96818
96819   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96820   {
96821     try {
96822       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96823     } catch (std::out_of_range& e) {
96824       {
96825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96826       };
96827     } catch (std::exception& e) {
96828       {
96829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96830       };
96831     } catch (Dali::DaliException e) {
96832       {
96833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96834       };
96835     } catch (...) {
96836       {
96837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96838       };
96839     }
96840   }
96841
96842   jresult = result;
96843   return jresult;
96844 }
96845
96846
96847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96848   unsigned long jresult ;
96849   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96850   std::size_t result;
96851
96852   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96853   {
96854     try {
96855       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96856     } catch (std::out_of_range& e) {
96857       {
96858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96859       };
96860     } catch (std::exception& e) {
96861       {
96862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96863       };
96864     } catch (Dali::DaliException e) {
96865       {
96866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96867       };
96868     } catch (...) {
96869       {
96870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96871       };
96872     }
96873   }
96874
96875   jresult = (unsigned long)result;
96876   return jresult;
96877 }
96878
96879
96880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96881   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96882   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96883
96884   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96885   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96886   {
96887     try {
96888       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96889     } catch (std::out_of_range& e) {
96890       {
96891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96892       };
96893     } catch (std::exception& e) {
96894       {
96895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96896       };
96897     } catch (Dali::DaliException e) {
96898       {
96899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96900       };
96901     } catch (...) {
96902       {
96903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96904       };
96905     }
96906   }
96907
96908 }
96909
96910
96911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96912   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96913   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96914
96915   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96916   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96917   {
96918     try {
96919       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96920     } catch (std::out_of_range& e) {
96921       {
96922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96923       };
96924     } catch (std::exception& e) {
96925       {
96926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96927       };
96928     } catch (Dali::DaliException e) {
96929       {
96930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96931       };
96932     } catch (...) {
96933       {
96934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96935       };
96936     }
96937   }
96938
96939 }
96940
96941
96942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96943   unsigned int jresult ;
96944   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96945   Dali::Toolkit::Button arg2 ;
96946   Dali::Toolkit::Button *argp2 ;
96947   bool result;
96948
96949   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96950   argp2 = (Dali::Toolkit::Button *)jarg2;
96951   if (!argp2) {
96952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96953     return 0;
96954   }
96955   arg2 = *argp2;
96956   {
96957     try {
96958       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96959     } catch (std::out_of_range& e) {
96960       {
96961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96962       };
96963     } catch (std::exception& e) {
96964       {
96965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96966       };
96967     } catch (Dali::DaliException e) {
96968       {
96969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96970       };
96971     } catch (...) {
96972       {
96973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96974       };
96975     }
96976   }
96977
96978   jresult = result;
96979   return jresult;
96980 }
96981
96982
96983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96984   void * jresult ;
96985   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96986
96987   {
96988     try {
96989       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96990     } catch (std::out_of_range& e) {
96991       {
96992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96993       };
96994     } catch (std::exception& e) {
96995       {
96996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96997       };
96998     } catch (Dali::DaliException e) {
96999       {
97000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97001       };
97002     } catch (...) {
97003       {
97004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97005       };
97006     }
97007   }
97008
97009   jresult = (void *)result;
97010   return jresult;
97011 }
97012
97013
97014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97015   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97016
97017   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97018   {
97019     try {
97020       delete arg1;
97021     } catch (std::out_of_range& e) {
97022       {
97023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97024       };
97025     } catch (std::exception& e) {
97026       {
97027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97028       };
97029     } catch (Dali::DaliException e) {
97030       {
97031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97032       };
97033     } catch (...) {
97034       {
97035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97036       };
97037     }
97038   }
97039
97040 }
97041
97042
97043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97044   unsigned int jresult ;
97045   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97046   bool result;
97047
97048   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97049   {
97050     try {
97051       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97052     } catch (std::out_of_range& e) {
97053       {
97054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97055       };
97056     } catch (std::exception& e) {
97057       {
97058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97059       };
97060     } catch (Dali::DaliException e) {
97061       {
97062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97063       };
97064     } catch (...) {
97065       {
97066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97067       };
97068     }
97069   }
97070
97071   jresult = result;
97072   return jresult;
97073 }
97074
97075
97076 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97077   unsigned long jresult ;
97078   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97079   std::size_t result;
97080
97081   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97082   {
97083     try {
97084       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97085     } catch (std::out_of_range& e) {
97086       {
97087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97088       };
97089     } catch (std::exception& e) {
97090       {
97091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97092       };
97093     } catch (Dali::DaliException e) {
97094       {
97095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97096       };
97097     } catch (...) {
97098       {
97099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97100       };
97101     }
97102   }
97103
97104   jresult = (unsigned long)result;
97105   return jresult;
97106 }
97107
97108
97109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97110   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97111   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97112
97113   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97114   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97115   {
97116     try {
97117       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97118     } catch (std::out_of_range& e) {
97119       {
97120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97121       };
97122     } catch (std::exception& e) {
97123       {
97124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97125       };
97126     } catch (Dali::DaliException e) {
97127       {
97128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97129       };
97130     } catch (...) {
97131       {
97132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97133       };
97134     }
97135   }
97136
97137 }
97138
97139
97140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97141   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97142   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97143
97144   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97145   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97146   {
97147     try {
97148       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97149     } catch (std::out_of_range& e) {
97150       {
97151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97152       };
97153     } catch (std::exception& e) {
97154       {
97155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97156       };
97157     } catch (Dali::DaliException e) {
97158       {
97159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97160       };
97161     } catch (...) {
97162       {
97163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97164       };
97165     }
97166   }
97167
97168 }
97169
97170
97171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97172   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97173   Dali::Toolkit::GaussianBlurView arg2 ;
97174   Dali::Toolkit::GaussianBlurView *argp2 ;
97175
97176   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97177   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97178   if (!argp2) {
97179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97180     return ;
97181   }
97182   arg2 = *argp2;
97183   {
97184     try {
97185       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97186     } catch (std::out_of_range& e) {
97187       {
97188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97189       };
97190     } catch (std::exception& e) {
97191       {
97192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97193       };
97194     } catch (Dali::DaliException e) {
97195       {
97196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97197       };
97198     } catch (...) {
97199       {
97200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97201       };
97202     }
97203   }
97204
97205 }
97206
97207
97208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97209   void * jresult ;
97210   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97211
97212   {
97213     try {
97214       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97215     } catch (std::out_of_range& e) {
97216       {
97217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97218       };
97219     } catch (std::exception& e) {
97220       {
97221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97222       };
97223     } catch (Dali::DaliException e) {
97224       {
97225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97226       };
97227     } catch (...) {
97228       {
97229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97230       };
97231     }
97232   }
97233
97234   jresult = (void *)result;
97235   return jresult;
97236 }
97237
97238
97239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97240   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97241
97242   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97243   {
97244     try {
97245       delete arg1;
97246     } catch (std::out_of_range& e) {
97247       {
97248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97249       };
97250     } catch (std::exception& e) {
97251       {
97252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97253       };
97254     } catch (Dali::DaliException e) {
97255       {
97256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97257       };
97258     } catch (...) {
97259       {
97260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97261       };
97262     }
97263   }
97264
97265 }
97266
97267
97268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97269   unsigned int jresult ;
97270   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97271   bool result;
97272
97273   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97274   {
97275     try {
97276       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);
97277     } catch (std::out_of_range& e) {
97278       {
97279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97280       };
97281     } catch (std::exception& e) {
97282       {
97283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97284       };
97285     } catch (Dali::DaliException e) {
97286       {
97287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97288       };
97289     } catch (...) {
97290       {
97291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97292       };
97293     }
97294   }
97295
97296   jresult = result;
97297   return jresult;
97298 }
97299
97300
97301 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97302   unsigned long jresult ;
97303   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97304   std::size_t result;
97305
97306   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97307   {
97308     try {
97309       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);
97310     } catch (std::out_of_range& e) {
97311       {
97312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97313       };
97314     } catch (std::exception& e) {
97315       {
97316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97317       };
97318     } catch (Dali::DaliException e) {
97319       {
97320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97321       };
97322     } catch (...) {
97323       {
97324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97325       };
97326     }
97327   }
97328
97329   jresult = (unsigned long)result;
97330   return jresult;
97331 }
97332
97333
97334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97335   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97336   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97337
97338   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97339   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97340   {
97341     try {
97342       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97343     } catch (std::out_of_range& e) {
97344       {
97345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97346       };
97347     } catch (std::exception& e) {
97348       {
97349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97350       };
97351     } catch (Dali::DaliException e) {
97352       {
97353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97354       };
97355     } catch (...) {
97356       {
97357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97358       };
97359     }
97360   }
97361
97362 }
97363
97364
97365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97366   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97367   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97368
97369   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97370   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97371   {
97372     try {
97373       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97374     } catch (std::out_of_range& e) {
97375       {
97376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97377       };
97378     } catch (std::exception& e) {
97379       {
97380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97381       };
97382     } catch (Dali::DaliException e) {
97383       {
97384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97385       };
97386     } catch (...) {
97387       {
97388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97389       };
97390     }
97391   }
97392
97393 }
97394
97395
97396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97397   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97398   Dali::Toolkit::PageTurnView arg2 ;
97399   unsigned int arg3 ;
97400   bool arg4 ;
97401   Dali::Toolkit::PageTurnView *argp2 ;
97402
97403   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97404   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97405   if (!argp2) {
97406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97407     return ;
97408   }
97409   arg2 = *argp2;
97410   arg3 = (unsigned int)jarg3;
97411   arg4 = jarg4 ? true : false;
97412   {
97413     try {
97414       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97415     } catch (std::out_of_range& e) {
97416       {
97417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97418       };
97419     } catch (std::exception& e) {
97420       {
97421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97422       };
97423     } catch (Dali::DaliException e) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97426       };
97427     } catch (...) {
97428       {
97429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97430       };
97431     }
97432   }
97433
97434 }
97435
97436
97437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97438   void * jresult ;
97439   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97440
97441   {
97442     try {
97443       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97444     } catch (std::out_of_range& e) {
97445       {
97446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97447       };
97448     } catch (std::exception& e) {
97449       {
97450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97451       };
97452     } catch (Dali::DaliException e) {
97453       {
97454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97455       };
97456     } catch (...) {
97457       {
97458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97459       };
97460     }
97461   }
97462
97463   jresult = (void *)result;
97464   return jresult;
97465 }
97466
97467
97468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97469   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97470
97471   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97472   {
97473     try {
97474       delete arg1;
97475     } catch (std::out_of_range& e) {
97476       {
97477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97478       };
97479     } catch (std::exception& e) {
97480       {
97481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97482       };
97483     } catch (Dali::DaliException e) {
97484       {
97485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97486       };
97487     } catch (...) {
97488       {
97489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97490       };
97491     }
97492   }
97493
97494 }
97495
97496
97497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97498   unsigned int jresult ;
97499   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97500   bool result;
97501
97502   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97503   {
97504     try {
97505       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97506     } catch (std::out_of_range& e) {
97507       {
97508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97509       };
97510     } catch (std::exception& e) {
97511       {
97512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97513       };
97514     } catch (Dali::DaliException e) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97517       };
97518     } catch (...) {
97519       {
97520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97521       };
97522     }
97523   }
97524
97525   jresult = result;
97526   return jresult;
97527 }
97528
97529
97530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97531   unsigned long jresult ;
97532   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97533   std::size_t result;
97534
97535   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97536   {
97537     try {
97538       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97539     } catch (std::out_of_range& e) {
97540       {
97541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97542       };
97543     } catch (std::exception& e) {
97544       {
97545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97546       };
97547     } catch (Dali::DaliException e) {
97548       {
97549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97550       };
97551     } catch (...) {
97552       {
97553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97554       };
97555     }
97556   }
97557
97558   jresult = (unsigned long)result;
97559   return jresult;
97560 }
97561
97562
97563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97564   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97565   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97566
97567   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97568   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97569   {
97570     try {
97571       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97572     } catch (std::out_of_range& e) {
97573       {
97574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97575       };
97576     } catch (std::exception& e) {
97577       {
97578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97579       };
97580     } catch (Dali::DaliException e) {
97581       {
97582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97583       };
97584     } catch (...) {
97585       {
97586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97587       };
97588     }
97589   }
97590
97591 }
97592
97593
97594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97595   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97596   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97597
97598   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97599   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97600   {
97601     try {
97602       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97603     } catch (std::out_of_range& e) {
97604       {
97605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97606       };
97607     } catch (std::exception& e) {
97608       {
97609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97610       };
97611     } catch (Dali::DaliException e) {
97612       {
97613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97614       };
97615     } catch (...) {
97616       {
97617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97618       };
97619     }
97620   }
97621
97622 }
97623
97624
97625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97626   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97627   Dali::Toolkit::PageTurnView arg2 ;
97628   Dali::Toolkit::PageTurnView *argp2 ;
97629
97630   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97631   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97632   if (!argp2) {
97633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97634     return ;
97635   }
97636   arg2 = *argp2;
97637   {
97638     try {
97639       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97640     } catch (std::out_of_range& e) {
97641       {
97642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97643       };
97644     } catch (std::exception& e) {
97645       {
97646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97647       };
97648     } catch (Dali::DaliException e) {
97649       {
97650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97651       };
97652     } catch (...) {
97653       {
97654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97655       };
97656     }
97657   }
97658
97659 }
97660
97661
97662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97663   void * jresult ;
97664   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97665
97666   {
97667     try {
97668       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97669     } catch (std::out_of_range& e) {
97670       {
97671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97672       };
97673     } catch (std::exception& e) {
97674       {
97675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97676       };
97677     } catch (Dali::DaliException e) {
97678       {
97679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97680       };
97681     } catch (...) {
97682       {
97683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97684       };
97685     }
97686   }
97687
97688   jresult = (void *)result;
97689   return jresult;
97690 }
97691
97692
97693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97694   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97695
97696   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97697   {
97698     try {
97699       delete arg1;
97700     } catch (std::out_of_range& e) {
97701       {
97702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97703       };
97704     } catch (std::exception& e) {
97705       {
97706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97707       };
97708     } catch (Dali::DaliException e) {
97709       {
97710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97711       };
97712     } catch (...) {
97713       {
97714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97715       };
97716     }
97717   }
97718
97719 }
97720
97721
97722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97723   unsigned int jresult ;
97724   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97725   bool result;
97726
97727   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97728   {
97729     try {
97730       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);
97731     } catch (std::out_of_range& e) {
97732       {
97733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97734       };
97735     } catch (std::exception& e) {
97736       {
97737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97738       };
97739     } catch (Dali::DaliException e) {
97740       {
97741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97742       };
97743     } catch (...) {
97744       {
97745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97746       };
97747     }
97748   }
97749
97750   jresult = result;
97751   return jresult;
97752 }
97753
97754
97755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97756   unsigned long jresult ;
97757   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97758   std::size_t result;
97759
97760   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97761   {
97762     try {
97763       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);
97764     } catch (std::out_of_range& e) {
97765       {
97766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97767       };
97768     } catch (std::exception& e) {
97769       {
97770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97771       };
97772     } catch (Dali::DaliException e) {
97773       {
97774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97775       };
97776     } catch (...) {
97777       {
97778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97779       };
97780     }
97781   }
97782
97783   jresult = (unsigned long)result;
97784   return jresult;
97785 }
97786
97787
97788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97789   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97790   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97791
97792   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97793   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97794   {
97795     try {
97796       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97797     } catch (std::out_of_range& e) {
97798       {
97799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97800       };
97801     } catch (std::exception& e) {
97802       {
97803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97804       };
97805     } catch (Dali::DaliException e) {
97806       {
97807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97808       };
97809     } catch (...) {
97810       {
97811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97812       };
97813     }
97814   }
97815
97816 }
97817
97818
97819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97820   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97821   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97822
97823   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97824   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97825   {
97826     try {
97827       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97828     } catch (std::out_of_range& e) {
97829       {
97830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97831       };
97832     } catch (std::exception& e) {
97833       {
97834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97835       };
97836     } catch (Dali::DaliException e) {
97837       {
97838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97839       };
97840     } catch (...) {
97841       {
97842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97843       };
97844     }
97845   }
97846
97847 }
97848
97849
97850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97851   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97852   Dali::Toolkit::ProgressBar arg2 ;
97853   float arg3 ;
97854   float arg4 ;
97855   Dali::Toolkit::ProgressBar *argp2 ;
97856
97857   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97858   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97859   if (!argp2) {
97860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97861     return ;
97862   }
97863   arg2 = *argp2;
97864   arg3 = (float)jarg3;
97865   arg4 = (float)jarg4;
97866   {
97867     try {
97868       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97869     } catch (std::out_of_range& e) {
97870       {
97871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97872       };
97873     } catch (std::exception& e) {
97874       {
97875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97876       };
97877     } catch (Dali::DaliException e) {
97878       {
97879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97880       };
97881     } catch (...) {
97882       {
97883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97884       };
97885     }
97886   }
97887
97888 }
97889
97890
97891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97892   void * jresult ;
97893   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97894
97895   {
97896     try {
97897       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97898     } catch (std::out_of_range& e) {
97899       {
97900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97901       };
97902     } catch (std::exception& e) {
97903       {
97904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97905       };
97906     } catch (Dali::DaliException e) {
97907       {
97908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97909       };
97910     } catch (...) {
97911       {
97912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97913       };
97914     }
97915   }
97916
97917   jresult = (void *)result;
97918   return jresult;
97919 }
97920
97921
97922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97923   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97924
97925   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97926   {
97927     try {
97928       delete arg1;
97929     } catch (std::out_of_range& e) {
97930       {
97931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97932       };
97933     } catch (std::exception& e) {
97934       {
97935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97936       };
97937     } catch (Dali::DaliException e) {
97938       {
97939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97940       };
97941     } catch (...) {
97942       {
97943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97944       };
97945     }
97946   }
97947
97948 }
97949
97950
97951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97952   unsigned int jresult ;
97953   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97954   bool result;
97955
97956   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97957   {
97958     try {
97959       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);
97960     } catch (std::out_of_range& e) {
97961       {
97962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97963       };
97964     } catch (std::exception& e) {
97965       {
97966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97967       };
97968     } catch (Dali::DaliException e) {
97969       {
97970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97971       };
97972     } catch (...) {
97973       {
97974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97975       };
97976     }
97977   }
97978
97979   jresult = result;
97980   return jresult;
97981 }
97982
97983
97984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97985   unsigned long jresult ;
97986   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97987   std::size_t result;
97988
97989   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97990   {
97991     try {
97992       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);
97993     } catch (std::out_of_range& e) {
97994       {
97995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97996       };
97997     } catch (std::exception& e) {
97998       {
97999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98000       };
98001     } catch (Dali::DaliException e) {
98002       {
98003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98004       };
98005     } catch (...) {
98006       {
98007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98008       };
98009     }
98010   }
98011
98012   jresult = (unsigned long)result;
98013   return jresult;
98014 }
98015
98016
98017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98018   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98019   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98020
98021   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98022   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98023   {
98024     try {
98025       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98026     } catch (std::out_of_range& e) {
98027       {
98028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98029       };
98030     } catch (std::exception& e) {
98031       {
98032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98033       };
98034     } catch (Dali::DaliException e) {
98035       {
98036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98037       };
98038     } catch (...) {
98039       {
98040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98041       };
98042     }
98043   }
98044
98045 }
98046
98047
98048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98049   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98050   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98051
98052   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98053   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98054   {
98055     try {
98056       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98057     } catch (std::out_of_range& e) {
98058       {
98059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98060       };
98061     } catch (std::exception& e) {
98062       {
98063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98064       };
98065     } catch (Dali::DaliException e) {
98066       {
98067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98068       };
98069     } catch (...) {
98070       {
98071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98072       };
98073     }
98074   }
98075
98076 }
98077
98078
98079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98080   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98081   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98082
98083   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98084   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98085   if (!arg2) {
98086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98087     return ;
98088   }
98089   {
98090     try {
98091       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98092     } catch (std::out_of_range& e) {
98093       {
98094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98095       };
98096     } catch (std::exception& e) {
98097       {
98098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98099       };
98100     } catch (Dali::DaliException e) {
98101       {
98102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98103       };
98104     } catch (...) {
98105       {
98106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98107       };
98108     }
98109   }
98110
98111 }
98112
98113
98114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98115   void * jresult ;
98116   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98117
98118   {
98119     try {
98120       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98121     } catch (std::out_of_range& e) {
98122       {
98123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98124       };
98125     } catch (std::exception& e) {
98126       {
98127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98128       };
98129     } catch (Dali::DaliException e) {
98130       {
98131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98132       };
98133     } catch (...) {
98134       {
98135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98136       };
98137     }
98138   }
98139
98140   jresult = (void *)result;
98141   return jresult;
98142 }
98143
98144
98145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98146   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98147
98148   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98149   {
98150     try {
98151       delete arg1;
98152     } catch (std::out_of_range& e) {
98153       {
98154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98155       };
98156     } catch (std::exception& e) {
98157       {
98158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98159       };
98160     } catch (Dali::DaliException e) {
98161       {
98162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98163       };
98164     } catch (...) {
98165       {
98166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98167       };
98168     }
98169   }
98170
98171 }
98172
98173
98174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98175   unsigned int jresult ;
98176   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98177   bool result;
98178
98179   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98180   {
98181     try {
98182       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 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 = result;
98203   return jresult;
98204 }
98205
98206
98207 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98208   unsigned long jresult ;
98209   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98210   std::size_t result;
98211
98212   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98213   {
98214     try {
98215       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98216     } catch (std::out_of_range& e) {
98217       {
98218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98219       };
98220     } catch (std::exception& e) {
98221       {
98222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98223       };
98224     } catch (Dali::DaliException e) {
98225       {
98226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98227       };
98228     } catch (...) {
98229       {
98230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98231       };
98232     }
98233   }
98234
98235   jresult = (unsigned long)result;
98236   return jresult;
98237 }
98238
98239
98240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98241   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98242   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98243
98244   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98245   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98246   {
98247     try {
98248       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98249     } catch (std::out_of_range& e) {
98250       {
98251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98252       };
98253     } catch (std::exception& e) {
98254       {
98255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98256       };
98257     } catch (Dali::DaliException e) {
98258       {
98259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98260       };
98261     } catch (...) {
98262       {
98263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98264       };
98265     }
98266   }
98267
98268 }
98269
98270
98271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98272   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98273   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98274
98275   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98276   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98277   {
98278     try {
98279       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98280     } catch (std::out_of_range& e) {
98281       {
98282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98283       };
98284     } catch (std::exception& e) {
98285       {
98286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98287       };
98288     } catch (Dali::DaliException e) {
98289       {
98290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98291       };
98292     } catch (...) {
98293       {
98294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98295       };
98296     }
98297   }
98298
98299 }
98300
98301
98302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98303   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98304   Dali::Vector2 *arg2 = 0 ;
98305
98306   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98307   arg2 = (Dali::Vector2 *)jarg2;
98308   if (!arg2) {
98309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98310     return ;
98311   }
98312   {
98313     try {
98314       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98315     } catch (std::out_of_range& e) {
98316       {
98317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98318       };
98319     } catch (std::exception& e) {
98320       {
98321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98322       };
98323     } catch (Dali::DaliException e) {
98324       {
98325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98326       };
98327     } catch (...) {
98328       {
98329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98330       };
98331     }
98332   }
98333
98334 }
98335
98336
98337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98338   void * jresult ;
98339   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98340
98341   {
98342     try {
98343       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98344     } catch (std::out_of_range& e) {
98345       {
98346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98347       };
98348     } catch (std::exception& e) {
98349       {
98350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98351       };
98352     } catch (Dali::DaliException e) {
98353       {
98354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98355       };
98356     } catch (...) {
98357       {
98358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98359       };
98360     }
98361   }
98362
98363   jresult = (void *)result;
98364   return jresult;
98365 }
98366
98367
98368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98369   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98370
98371   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98372   {
98373     try {
98374       delete arg1;
98375     } catch (std::out_of_range& e) {
98376       {
98377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98378       };
98379     } catch (std::exception& e) {
98380       {
98381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98382       };
98383     } catch (Dali::DaliException e) {
98384       {
98385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98386       };
98387     } catch (...) {
98388       {
98389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98390       };
98391     }
98392   }
98393
98394 }
98395
98396
98397
98398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98399   unsigned int jresult ;
98400   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98401   bool result;
98402
98403   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98404   {
98405     try {
98406       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);
98407     } catch (std::out_of_range& e) {
98408       {
98409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98410       };
98411     } catch (std::exception& e) {
98412       {
98413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98414       };
98415     } catch (Dali::DaliException e) {
98416       {
98417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98418       };
98419     } catch (...) {
98420       {
98421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98422       };
98423     }
98424   }
98425
98426   jresult = result;
98427   return jresult;
98428 }
98429
98430
98431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98432   unsigned long jresult ;
98433   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98434   std::size_t result;
98435
98436   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98437   {
98438     try {
98439       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);
98440     } catch (std::out_of_range& e) {
98441       {
98442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98443       };
98444     } catch (std::exception& e) {
98445       {
98446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98447       };
98448     } catch (Dali::DaliException e) {
98449       {
98450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98451       };
98452     } catch (...) {
98453       {
98454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98455       };
98456     }
98457   }
98458
98459   jresult = (unsigned long)result;
98460   return jresult;
98461 }
98462
98463
98464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98465   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98466   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98467
98468   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98469   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98470   {
98471     try {
98472       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98473     } catch (std::out_of_range& e) {
98474       {
98475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98476       };
98477     } catch (std::exception& e) {
98478       {
98479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98480       };
98481     } catch (Dali::DaliException e) {
98482       {
98483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98484       };
98485     } catch (...) {
98486       {
98487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98488       };
98489     }
98490   }
98491
98492 }
98493
98494
98495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98496   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98497   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98498
98499   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98500   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98501   {
98502     try {
98503       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98504     } catch (std::out_of_range& e) {
98505       {
98506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98507       };
98508     } catch (std::exception& e) {
98509       {
98510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98511       };
98512     } catch (Dali::DaliException e) {
98513       {
98514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98515       };
98516     } catch (...) {
98517       {
98518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98519       };
98520     }
98521   }
98522
98523 }
98524
98525
98526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98527   unsigned int jresult ;
98528   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98529   Dali::Toolkit::Control arg2 ;
98530   Dali::KeyEvent *arg3 = 0 ;
98531   Dali::Toolkit::Control *argp2 ;
98532   bool result;
98533
98534   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98535   argp2 = (Dali::Toolkit::Control *)jarg2;
98536   if (!argp2) {
98537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98538     return 0;
98539   }
98540   arg2 = *argp2;
98541   arg3 = (Dali::KeyEvent *)jarg3;
98542   if (!arg3) {
98543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98544     return 0;
98545   }
98546   {
98547     try {
98548       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);
98549     } catch (std::out_of_range& e) {
98550       {
98551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98552       };
98553     } catch (std::exception& e) {
98554       {
98555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98556       };
98557     } catch (Dali::DaliException e) {
98558       {
98559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98560       };
98561     } catch (...) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98564       };
98565     }
98566   }
98567
98568   jresult = result;
98569   return jresult;
98570 }
98571
98572
98573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98574   void * jresult ;
98575   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98576
98577   {
98578     try {
98579       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98580     } catch (std::out_of_range& e) {
98581       {
98582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98583       };
98584     } catch (std::exception& e) {
98585       {
98586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98587       };
98588     } catch (Dali::DaliException e) {
98589       {
98590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98591       };
98592     } catch (...) {
98593       {
98594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98595       };
98596     }
98597   }
98598
98599   jresult = (void *)result;
98600   return jresult;
98601 }
98602
98603
98604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98605   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98606
98607   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98608   {
98609     try {
98610       delete arg1;
98611     } catch (std::out_of_range& e) {
98612       {
98613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98614       };
98615     } catch (std::exception& e) {
98616       {
98617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98618       };
98619     } catch (Dali::DaliException e) {
98620       {
98621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98622       };
98623     } catch (...) {
98624       {
98625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98626       };
98627     }
98628   }
98629
98630 }
98631
98632
98633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98634   unsigned int jresult ;
98635   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98636   bool result;
98637
98638   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98639   {
98640     try {
98641       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98642     } catch (std::out_of_range& e) {
98643       {
98644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98645       };
98646     } catch (std::exception& e) {
98647       {
98648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98649       };
98650     } catch (Dali::DaliException e) {
98651       {
98652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98653       };
98654     } catch (...) {
98655       {
98656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98657       };
98658     }
98659   }
98660
98661   jresult = result;
98662   return jresult;
98663 }
98664
98665
98666 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98667   unsigned long jresult ;
98668   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98669   std::size_t result;
98670
98671   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98672   {
98673     try {
98674       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98675     } catch (std::out_of_range& e) {
98676       {
98677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98678       };
98679     } catch (std::exception& e) {
98680       {
98681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98682       };
98683     } catch (Dali::DaliException e) {
98684       {
98685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98686       };
98687     } catch (...) {
98688       {
98689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98690       };
98691     }
98692   }
98693
98694   jresult = (unsigned long)result;
98695   return jresult;
98696 }
98697
98698
98699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98700   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98701   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98702
98703   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98704   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98705   {
98706     try {
98707       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98708     } catch (std::out_of_range& e) {
98709       {
98710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98711       };
98712     } catch (std::exception& e) {
98713       {
98714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98715       };
98716     } catch (Dali::DaliException e) {
98717       {
98718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98719       };
98720     } catch (...) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98723       };
98724     }
98725   }
98726
98727 }
98728
98729
98730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98731   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98732   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98733
98734   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98735   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98736   {
98737     try {
98738       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98739     } catch (std::out_of_range& e) {
98740       {
98741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98742       };
98743     } catch (std::exception& e) {
98744       {
98745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98746       };
98747     } catch (Dali::DaliException e) {
98748       {
98749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98750       };
98751     } catch (...) {
98752       {
98753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98754       };
98755     }
98756   }
98757
98758 }
98759
98760
98761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98762   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98763   Dali::Toolkit::Control arg2 ;
98764   Dali::Toolkit::Control *argp2 ;
98765
98766   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98767   argp2 = (Dali::Toolkit::Control *)jarg2;
98768   if (!argp2) {
98769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98770     return ;
98771   }
98772   arg2 = *argp2;
98773   {
98774     try {
98775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98776     } catch (std::out_of_range& e) {
98777       {
98778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98779       };
98780     } catch (std::exception& e) {
98781       {
98782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98783       };
98784     } catch (Dali::DaliException e) {
98785       {
98786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98787       };
98788     } catch (...) {
98789       {
98790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98791       };
98792     }
98793   }
98794
98795 }
98796
98797
98798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98799   void * jresult ;
98800   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98801
98802   {
98803     try {
98804       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98805     } catch (std::out_of_range& e) {
98806       {
98807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98808       };
98809     } catch (std::exception& e) {
98810       {
98811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98812       };
98813     } catch (Dali::DaliException e) {
98814       {
98815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98816       };
98817     } catch (...) {
98818       {
98819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98820       };
98821     }
98822   }
98823
98824   jresult = (void *)result;
98825   return jresult;
98826 }
98827
98828
98829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98830   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98831
98832   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98833   {
98834     try {
98835       delete arg1;
98836     } catch (std::out_of_range& e) {
98837       {
98838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98839       };
98840     } catch (std::exception& e) {
98841       {
98842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98843       };
98844     } catch (Dali::DaliException e) {
98845       {
98846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98847       };
98848     } catch (...) {
98849       {
98850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98851       };
98852     }
98853   }
98854
98855 }
98856
98857
98858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98859   unsigned int jresult ;
98860   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98861   bool result;
98862
98863   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98864   {
98865     try {
98866       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98867     } catch (std::out_of_range& e) {
98868       {
98869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98870       };
98871     } catch (std::exception& e) {
98872       {
98873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98874       };
98875     } catch (Dali::DaliException e) {
98876       {
98877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98878       };
98879     } catch (...) {
98880       {
98881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98882       };
98883     }
98884   }
98885
98886   jresult = result;
98887   return jresult;
98888 }
98889
98890
98891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98892   unsigned long jresult ;
98893   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98894   std::size_t result;
98895
98896   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98897   {
98898     try {
98899       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98900     } catch (std::out_of_range& e) {
98901       {
98902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98903       };
98904     } catch (std::exception& e) {
98905       {
98906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98907       };
98908     } catch (Dali::DaliException e) {
98909       {
98910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98911       };
98912     } catch (...) {
98913       {
98914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98915       };
98916     }
98917   }
98918
98919   jresult = (unsigned long)result;
98920   return jresult;
98921 }
98922
98923
98924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98925   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98926   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98927
98928   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98929   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98930   {
98931     try {
98932       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98933     } catch (std::out_of_range& e) {
98934       {
98935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98936       };
98937     } catch (std::exception& e) {
98938       {
98939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98940       };
98941     } catch (Dali::DaliException e) {
98942       {
98943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98944       };
98945     } catch (...) {
98946       {
98947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98948       };
98949     }
98950   }
98951
98952 }
98953
98954
98955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98956   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98957   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98958
98959   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98960   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98961   {
98962     try {
98963       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98964     } catch (std::out_of_range& e) {
98965       {
98966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98967       };
98968     } catch (std::exception& e) {
98969       {
98970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98971       };
98972     } catch (Dali::DaliException e) {
98973       {
98974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98975       };
98976     } catch (...) {
98977       {
98978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98979       };
98980     }
98981   }
98982
98983 }
98984
98985
98986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98987   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98988   Dali::Toolkit::VideoView *arg2 = 0 ;
98989
98990   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98991   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98992   if (!arg2) {
98993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98994     return ;
98995   }
98996   {
98997     try {
98998       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98999     } catch (std::out_of_range& e) {
99000       {
99001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99002       };
99003     } catch (std::exception& e) {
99004       {
99005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99006       };
99007     } catch (Dali::DaliException e) {
99008       {
99009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99010       };
99011     } catch (...) {
99012       {
99013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99014       };
99015     }
99016   }
99017
99018 }
99019
99020
99021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99022   void * jresult ;
99023   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99024
99025   {
99026     try {
99027       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99028     } catch (std::out_of_range& e) {
99029       {
99030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99031       };
99032     } catch (std::exception& e) {
99033       {
99034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99035       };
99036     } catch (Dali::DaliException e) {
99037       {
99038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99039       };
99040     } catch (...) {
99041       {
99042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99043       };
99044     }
99045   }
99046
99047   jresult = (void *)result;
99048   return jresult;
99049 }
99050
99051
99052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99053   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99054
99055   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99056   {
99057     try {
99058       delete arg1;
99059     } catch (std::out_of_range& e) {
99060       {
99061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99062       };
99063     } catch (std::exception& e) {
99064       {
99065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99066       };
99067     } catch (Dali::DaliException e) {
99068       {
99069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99070       };
99071     } catch (...) {
99072       {
99073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99074       };
99075     }
99076   }
99077
99078 }
99079
99080
99081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99082   unsigned int jresult ;
99083   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99084   bool result;
99085
99086   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99087   {
99088     try {
99089       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99090     } catch (std::out_of_range& e) {
99091       {
99092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99093       };
99094     } catch (std::exception& e) {
99095       {
99096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99097       };
99098     } catch (Dali::DaliException e) {
99099       {
99100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99101       };
99102     } catch (...) {
99103       {
99104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99105       };
99106     }
99107   }
99108
99109   jresult = result;
99110   return jresult;
99111 }
99112
99113
99114 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99115   unsigned long jresult ;
99116   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99117   std::size_t result;
99118
99119   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99120   {
99121     try {
99122       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99123     } catch (std::out_of_range& e) {
99124       {
99125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99126       };
99127     } catch (std::exception& e) {
99128       {
99129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99130       };
99131     } catch (Dali::DaliException e) {
99132       {
99133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99134       };
99135     } catch (...) {
99136       {
99137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99138       };
99139     }
99140   }
99141
99142   jresult = (unsigned long)result;
99143   return jresult;
99144 }
99145
99146
99147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99148   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99149   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99150
99151   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99152   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99153   {
99154     try {
99155       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99156     } catch (std::out_of_range& e) {
99157       {
99158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99159       };
99160     } catch (std::exception& e) {
99161       {
99162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99163       };
99164     } catch (Dali::DaliException e) {
99165       {
99166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99167       };
99168     } catch (...) {
99169       {
99170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99171       };
99172     }
99173   }
99174
99175 }
99176
99177
99178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99179   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99180   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99181
99182   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99183   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99184   {
99185     try {
99186       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99187     } catch (std::out_of_range& e) {
99188       {
99189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99190       };
99191     } catch (std::exception& e) {
99192       {
99193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99194       };
99195     } catch (Dali::DaliException e) {
99196       {
99197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99198       };
99199     } catch (...) {
99200       {
99201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99202       };
99203     }
99204   }
99205
99206 }
99207
99208
99209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99210   unsigned int jresult ;
99211   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99212   Dali::Toolkit::Slider arg2 ;
99213   float arg3 ;
99214   Dali::Toolkit::Slider *argp2 ;
99215   bool result;
99216
99217   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99218   argp2 = (Dali::Toolkit::Slider *)jarg2;
99219   if (!argp2) {
99220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99221     return 0;
99222   }
99223   arg2 = *argp2;
99224   arg3 = (float)jarg3;
99225   {
99226     try {
99227       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99228     } catch (std::out_of_range& e) {
99229       {
99230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99231       };
99232     } catch (std::exception& e) {
99233       {
99234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99235       };
99236     } catch (Dali::DaliException e) {
99237       {
99238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99239       };
99240     } catch (...) {
99241       {
99242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99243       };
99244     }
99245   }
99246
99247   jresult = result;
99248   return jresult;
99249 }
99250
99251
99252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99253   void * jresult ;
99254   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99255
99256   {
99257     try {
99258       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99259     } catch (std::out_of_range& e) {
99260       {
99261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99262       };
99263     } catch (std::exception& e) {
99264       {
99265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99266       };
99267     } catch (Dali::DaliException e) {
99268       {
99269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99270       };
99271     } catch (...) {
99272       {
99273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99274       };
99275     }
99276   }
99277
99278   jresult = (void *)result;
99279   return jresult;
99280 }
99281
99282
99283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99284   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99285
99286   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99287   {
99288     try {
99289       delete arg1;
99290     } catch (std::out_of_range& e) {
99291       {
99292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99293       };
99294     } catch (std::exception& e) {
99295       {
99296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99297       };
99298     } catch (Dali::DaliException e) {
99299       {
99300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99301       };
99302     } catch (...) {
99303       {
99304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99305       };
99306     }
99307   }
99308
99309 }
99310
99311
99312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99313   unsigned int jresult ;
99314   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99315   bool result;
99316
99317   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99318   {
99319     try {
99320       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99321     } catch (std::out_of_range& e) {
99322       {
99323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99324       };
99325     } catch (std::exception& e) {
99326       {
99327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99328       };
99329     } catch (Dali::DaliException e) {
99330       {
99331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99332       };
99333     } catch (...) {
99334       {
99335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99336       };
99337     }
99338   }
99339
99340   jresult = result;
99341   return jresult;
99342 }
99343
99344
99345 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99346   unsigned long jresult ;
99347   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99348   std::size_t result;
99349
99350   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99351   {
99352     try {
99353       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99354     } catch (std::out_of_range& e) {
99355       {
99356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99357       };
99358     } catch (std::exception& e) {
99359       {
99360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99361       };
99362     } catch (Dali::DaliException e) {
99363       {
99364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99365       };
99366     } catch (...) {
99367       {
99368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99369       };
99370     }
99371   }
99372
99373   jresult = (unsigned long)result;
99374   return jresult;
99375 }
99376
99377
99378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99379   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99380   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99381
99382   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99383   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99384   {
99385     try {
99386       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99387     } catch (std::out_of_range& e) {
99388       {
99389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99390       };
99391     } catch (std::exception& e) {
99392       {
99393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99394       };
99395     } catch (Dali::DaliException e) {
99396       {
99397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99398       };
99399     } catch (...) {
99400       {
99401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99402       };
99403     }
99404   }
99405
99406 }
99407
99408
99409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99410   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99411   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99412
99413   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99414   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99415   {
99416     try {
99417       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99418     } catch (std::out_of_range& e) {
99419       {
99420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99421       };
99422     } catch (std::exception& e) {
99423       {
99424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99425       };
99426     } catch (Dali::DaliException e) {
99427       {
99428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99429       };
99430     } catch (...) {
99431       {
99432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99433       };
99434     }
99435   }
99436
99437 }
99438
99439
99440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99441   unsigned int jresult ;
99442   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99443   Dali::Toolkit::Slider arg2 ;
99444   int arg3 ;
99445   Dali::Toolkit::Slider *argp2 ;
99446   bool result;
99447
99448   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99449   argp2 = (Dali::Toolkit::Slider *)jarg2;
99450   if (!argp2) {
99451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99452     return 0;
99453   }
99454   arg2 = *argp2;
99455   arg3 = (int)jarg3;
99456   {
99457     try {
99458       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99459     } catch (std::out_of_range& e) {
99460       {
99461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99462       };
99463     } catch (std::exception& e) {
99464       {
99465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99466       };
99467     } catch (Dali::DaliException e) {
99468       {
99469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99470       };
99471     } catch (...) {
99472       {
99473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99474       };
99475     }
99476   }
99477
99478   jresult = result;
99479   return jresult;
99480 }
99481
99482
99483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99484   void * jresult ;
99485   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99486
99487   {
99488     try {
99489       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99490     } catch (std::out_of_range& e) {
99491       {
99492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99493       };
99494     } catch (std::exception& e) {
99495       {
99496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99497       };
99498     } catch (Dali::DaliException e) {
99499       {
99500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99501       };
99502     } catch (...) {
99503       {
99504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99505       };
99506     }
99507   }
99508
99509   jresult = (void *)result;
99510   return jresult;
99511 }
99512
99513
99514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99515   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99516
99517   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99518   {
99519     try {
99520       delete arg1;
99521     } catch (std::out_of_range& e) {
99522       {
99523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99524       };
99525     } catch (std::exception& e) {
99526       {
99527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99528       };
99529     } catch (Dali::DaliException e) {
99530       {
99531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99532       };
99533     } catch (...) {
99534       {
99535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99536       };
99537     }
99538   }
99539
99540 }
99541
99542
99543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99544   void * jresult ;
99545   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99546
99547   {
99548     try {
99549       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99550     } catch (std::out_of_range& e) {
99551       {
99552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99553       };
99554     } catch (std::exception& e) {
99555       {
99556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99557       };
99558     } catch (Dali::DaliException e) {
99559       {
99560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99561       };
99562     } catch (...) {
99563       {
99564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99565       };
99566     }
99567   }
99568
99569   jresult = (void *)result;
99570   return jresult;
99571 }
99572
99573
99574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99575   void * jresult ;
99576   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99577   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99578
99579   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99580   {
99581     try {
99582       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99583     } catch (std::out_of_range& e) {
99584       {
99585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99586       };
99587     } catch (std::exception& e) {
99588       {
99589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99590       };
99591     } catch (Dali::DaliException e) {
99592       {
99593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99594       };
99595     } catch (...) {
99596       {
99597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99598       };
99599     }
99600   }
99601
99602   jresult = (void *)result;
99603   return jresult;
99604 }
99605
99606
99607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99608   void * jresult ;
99609   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99610   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99611
99612   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99613   if (!arg1) {
99614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99615     return 0;
99616   }
99617   {
99618     try {
99619       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99620     } catch (std::out_of_range& e) {
99621       {
99622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99623       };
99624     } catch (std::exception& e) {
99625       {
99626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99627       };
99628     } catch (Dali::DaliException e) {
99629       {
99630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99631       };
99632     } catch (...) {
99633       {
99634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99635       };
99636     }
99637   }
99638
99639   jresult = (void *)result;
99640   return jresult;
99641 }
99642
99643
99644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99645   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99646
99647   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99648   {
99649     try {
99650       delete arg1;
99651     } catch (std::out_of_range& e) {
99652       {
99653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99654       };
99655     } catch (std::exception& e) {
99656       {
99657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99658       };
99659     } catch (Dali::DaliException e) {
99660       {
99661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99662       };
99663     } catch (...) {
99664       {
99665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99666       };
99667     }
99668   }
99669
99670 }
99671
99672
99673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99674   void * jresult ;
99675   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99676   Dali::Toolkit::Ruler *result = 0 ;
99677
99678   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99679   {
99680     try {
99681       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99682     } catch (std::out_of_range& e) {
99683       {
99684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99685       };
99686     } catch (std::exception& e) {
99687       {
99688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99689       };
99690     } catch (Dali::DaliException e) {
99691       {
99692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99693       };
99694     } catch (...) {
99695       {
99696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99697       };
99698     }
99699   }
99700
99701   jresult = (void *)result;
99702   return jresult;
99703 }
99704
99705
99706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99707   void * jresult ;
99708   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99709   Dali::Toolkit::Ruler *result = 0 ;
99710
99711   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99712   {
99713     try {
99714       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99715     } catch (std::out_of_range& e) {
99716       {
99717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99718       };
99719     } catch (std::exception& e) {
99720       {
99721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99722       };
99723     } catch (Dali::DaliException e) {
99724       {
99725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99726       };
99727     } catch (...) {
99728       {
99729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99730       };
99731     }
99732   }
99733
99734   jresult = (void *)result;
99735   return jresult;
99736 }
99737
99738
99739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99740   void * jresult ;
99741   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99742   Dali::Toolkit::Ruler *result = 0 ;
99743
99744   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99745   {
99746     try {
99747       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99748     } catch (std::out_of_range& e) {
99749       {
99750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99751       };
99752     } catch (std::exception& e) {
99753       {
99754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99755       };
99756     } catch (Dali::DaliException e) {
99757       {
99758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99759       };
99760     } catch (...) {
99761       {
99762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99763       };
99764     }
99765   }
99766
99767   jresult = (void *)result;
99768   return jresult;
99769 }
99770
99771
99772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99773   void * jresult ;
99774   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99775   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99776   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99777
99778   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99779   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99780   if (!arg2) {
99781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99782     return 0;
99783   }
99784   {
99785     try {
99786       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99787     } catch (std::out_of_range& e) {
99788       {
99789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99790       };
99791     } catch (std::exception& e) {
99792       {
99793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99794       };
99795     } catch (Dali::DaliException e) {
99796       {
99797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99798       };
99799     } catch (...) {
99800       {
99801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99802       };
99803     }
99804   }
99805
99806   jresult = (void *)result;
99807   return jresult;
99808 }
99809
99810
99811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99812   void * jresult ;
99813   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99814   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99815   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99816
99817   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99818   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99819   {
99820     try {
99821       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99822     } catch (std::out_of_range& e) {
99823       {
99824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99825       };
99826     } catch (std::exception& e) {
99827       {
99828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99829       };
99830     } catch (Dali::DaliException e) {
99831       {
99832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99833       };
99834     } catch (...) {
99835       {
99836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99837       };
99838     }
99839   }
99840
99841   jresult = (void *)result;
99842   return jresult;
99843 }
99844
99845
99846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99847   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99848
99849   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99850   {
99851     try {
99852       (arg1)->Reset();
99853     } catch (std::out_of_range& e) {
99854       {
99855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99856       };
99857     } catch (std::exception& e) {
99858       {
99859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99860       };
99861     } catch (Dali::DaliException e) {
99862       {
99863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99864       };
99865     } catch (...) {
99866       {
99867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99868       };
99869     }
99870   }
99871
99872 }
99873
99874
99875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99876   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99877   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99878
99879   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99880   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99881   {
99882     try {
99883       (arg1)->Reset(arg2);
99884     } catch (std::out_of_range& e) {
99885       {
99886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99887       };
99888     } catch (std::exception& e) {
99889       {
99890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99891       };
99892     } catch (Dali::DaliException e) {
99893       {
99894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99895       };
99896     } catch (...) {
99897       {
99898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99899       };
99900     }
99901   }
99902
99903 }
99904
99905
99906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99907   void * jresult ;
99908   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99909   Dali::Toolkit::Ruler *result = 0 ;
99910
99911   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99912   {
99913     try {
99914       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99915     } catch (std::out_of_range& e) {
99916       {
99917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99918       };
99919     } catch (std::exception& e) {
99920       {
99921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99922       };
99923     } catch (Dali::DaliException e) {
99924       {
99925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99926       };
99927     } catch (...) {
99928       {
99929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99930       };
99931     }
99932   }
99933
99934   jresult = (void *)result;
99935   return jresult;
99936 }
99937
99938
99939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99940   float jresult ;
99941   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99942   float arg2 ;
99943   float arg3 ;
99944   float result;
99945
99946   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99947   arg2 = (float)jarg2;
99948   arg3 = (float)jarg3;
99949   {
99950     try {
99951       result = (float)(*arg1)->Snap(arg2,arg3);
99952     } catch (std::out_of_range& e) {
99953       {
99954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99955       };
99956     } catch (std::exception& e) {
99957       {
99958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99959       };
99960     } catch (Dali::DaliException e) {
99961       {
99962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99963       };
99964     } catch (...) {
99965       {
99966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99967       };
99968     }
99969   }
99970
99971   jresult = result;
99972   return jresult;
99973 }
99974
99975
99976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99977   float jresult ;
99978   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99979   float arg2 ;
99980   float result;
99981
99982   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99983   arg2 = (float)jarg2;
99984   {
99985     try {
99986       result = (float)(*arg1)->Snap(arg2);
99987     } catch (std::out_of_range& e) {
99988       {
99989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99990       };
99991     } catch (std::exception& e) {
99992       {
99993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99994       };
99995     } catch (Dali::DaliException e) {
99996       {
99997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99998       };
99999     } catch (...) {
100000       {
100001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100002       };
100003     }
100004   }
100005
100006   jresult = result;
100007   return jresult;
100008 }
100009
100010
100011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100012   float jresult ;
100013   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100014   unsigned int arg2 ;
100015   unsigned int *arg3 = 0 ;
100016   bool arg4 ;
100017   float result;
100018
100019   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100020   arg2 = (unsigned int)jarg2;
100021   arg3 = (unsigned int *)jarg3;
100022   arg4 = jarg4 ? true : false;
100023   {
100024     try {
100025       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100026     } catch (std::out_of_range& e) {
100027       {
100028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100029       };
100030     } catch (std::exception& e) {
100031       {
100032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100033       };
100034     } catch (Dali::DaliException e) {
100035       {
100036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100037       };
100038     } catch (...) {
100039       {
100040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100041       };
100042     }
100043   }
100044
100045   jresult = result;
100046   return jresult;
100047 }
100048
100049
100050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100051   unsigned int jresult ;
100052   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100053   float arg2 ;
100054   bool arg3 ;
100055   unsigned int result;
100056
100057   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100058   arg2 = (float)jarg2;
100059   arg3 = jarg3 ? true : false;
100060   {
100061     try {
100062       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100063     } catch (std::out_of_range& e) {
100064       {
100065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100066       };
100067     } catch (std::exception& e) {
100068       {
100069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100070       };
100071     } catch (Dali::DaliException e) {
100072       {
100073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100074       };
100075     } catch (...) {
100076       {
100077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100078       };
100079     }
100080   }
100081
100082   jresult = result;
100083   return jresult;
100084 }
100085
100086
100087 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100088   unsigned int jresult ;
100089   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100090   unsigned int result;
100091
100092   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100093   {
100094     try {
100095       result = (unsigned int)(*arg1)->GetTotalPages();
100096     } catch (std::out_of_range& e) {
100097       {
100098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100099       };
100100     } catch (std::exception& e) {
100101       {
100102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100103       };
100104     } catch (Dali::DaliException e) {
100105       {
100106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100107       };
100108     } catch (...) {
100109       {
100110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100111       };
100112     }
100113   }
100114
100115   jresult = result;
100116   return jresult;
100117 }
100118
100119
100120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100121   int jresult ;
100122   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100123   Dali::Toolkit::Ruler::RulerType result;
100124
100125   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100126   {
100127     try {
100128       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100129     } catch (std::out_of_range& e) {
100130       {
100131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100132       };
100133     } catch (std::exception& e) {
100134       {
100135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100136       };
100137     } catch (Dali::DaliException e) {
100138       {
100139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100140       };
100141     } catch (...) {
100142       {
100143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100144       };
100145     }
100146   }
100147
100148   jresult = (int)result;
100149   return jresult;
100150 }
100151
100152
100153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100154   unsigned int jresult ;
100155   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100156   bool result;
100157
100158   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100159   {
100160     try {
100161       result = (bool)(*arg1)->IsEnabled();
100162     } catch (std::out_of_range& e) {
100163       {
100164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100165       };
100166     } catch (std::exception& e) {
100167       {
100168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100169       };
100170     } catch (Dali::DaliException e) {
100171       {
100172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100173       };
100174     } catch (...) {
100175       {
100176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100177       };
100178     }
100179   }
100180
100181   jresult = result;
100182   return jresult;
100183 }
100184
100185
100186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100187   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100188
100189   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100190   {
100191     try {
100192       (*arg1)->Enable();
100193     } catch (std::out_of_range& e) {
100194       {
100195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100196       };
100197     } catch (std::exception& e) {
100198       {
100199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100200       };
100201     } catch (Dali::DaliException e) {
100202       {
100203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100204       };
100205     } catch (...) {
100206       {
100207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100208       };
100209     }
100210   }
100211
100212 }
100213
100214
100215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100216   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100217
100218   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100219   {
100220     try {
100221       (*arg1)->Disable();
100222     } catch (std::out_of_range& e) {
100223       {
100224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100225       };
100226     } catch (std::exception& e) {
100227       {
100228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100229       };
100230     } catch (Dali::DaliException e) {
100231       {
100232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100233       };
100234     } catch (...) {
100235       {
100236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100237       };
100238     }
100239   }
100240
100241 }
100242
100243
100244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100245   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100246   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100247   Dali::Toolkit::RulerDomain *argp2 ;
100248
100249   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100250   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100251   if (!argp2) {
100252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100253     return ;
100254   }
100255   arg2 = *argp2;
100256   {
100257     try {
100258       (*arg1)->SetDomain(arg2);
100259     } catch (std::out_of_range& e) {
100260       {
100261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100262       };
100263     } catch (std::exception& e) {
100264       {
100265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100266       };
100267     } catch (Dali::DaliException e) {
100268       {
100269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100270       };
100271     } catch (...) {
100272       {
100273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100274       };
100275     }
100276   }
100277
100278 }
100279
100280
100281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100282   void * jresult ;
100283   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100284   Dali::Toolkit::RulerDomain *result = 0 ;
100285
100286   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100287   {
100288     try {
100289       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100290     } catch (std::out_of_range& e) {
100291       {
100292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100293       };
100294     } catch (std::exception& e) {
100295       {
100296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100297       };
100298     } catch (Dali::DaliException e) {
100299       {
100300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100301       };
100302     } catch (...) {
100303       {
100304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100305       };
100306     }
100307   }
100308
100309   jresult = (void *)result;
100310   return jresult;
100311 }
100312
100313
100314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100315   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100316
100317   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100318   {
100319     try {
100320       (*arg1)->DisableDomain();
100321     } catch (std::out_of_range& e) {
100322       {
100323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100324       };
100325     } catch (std::exception& e) {
100326       {
100327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100328       };
100329     } catch (Dali::DaliException e) {
100330       {
100331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100332       };
100333     } catch (...) {
100334       {
100335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100336       };
100337     }
100338   }
100339
100340 }
100341
100342
100343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100344   float jresult ;
100345   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100346   float arg2 ;
100347   float arg3 ;
100348   float arg4 ;
100349   float result;
100350
100351   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100352   arg2 = (float)jarg2;
100353   arg3 = (float)jarg3;
100354   arg4 = (float)jarg4;
100355   {
100356     try {
100357       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100358     } catch (std::out_of_range& e) {
100359       {
100360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100361       };
100362     } catch (std::exception& e) {
100363       {
100364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100365       };
100366     } catch (Dali::DaliException e) {
100367       {
100368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100369       };
100370     } catch (...) {
100371       {
100372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100373       };
100374     }
100375   }
100376
100377   jresult = result;
100378   return jresult;
100379 }
100380
100381
100382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100383   float jresult ;
100384   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100385   float arg2 ;
100386   float arg3 ;
100387   float result;
100388
100389   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100390   arg2 = (float)jarg2;
100391   arg3 = (float)jarg3;
100392   {
100393     try {
100394       result = (float)(*arg1)->Clamp(arg2,arg3);
100395     } catch (std::out_of_range& e) {
100396       {
100397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100398       };
100399     } catch (std::exception& e) {
100400       {
100401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100402       };
100403     } catch (Dali::DaliException e) {
100404       {
100405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100406       };
100407     } catch (...) {
100408       {
100409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100410       };
100411     }
100412   }
100413
100414   jresult = result;
100415   return jresult;
100416 }
100417
100418
100419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100420   float jresult ;
100421   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100422   float arg2 ;
100423   float result;
100424
100425   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100426   arg2 = (float)jarg2;
100427   {
100428     try {
100429       result = (float)(*arg1)->Clamp(arg2);
100430     } catch (std::out_of_range& e) {
100431       {
100432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100433       };
100434     } catch (std::exception& e) {
100435       {
100436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100437       };
100438     } catch (Dali::DaliException e) {
100439       {
100440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100441       };
100442     } catch (...) {
100443       {
100444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100445       };
100446     }
100447   }
100448
100449   jresult = result;
100450   return jresult;
100451 }
100452
100453
100454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100455   float jresult ;
100456   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100457   float arg2 ;
100458   float arg3 ;
100459   float arg4 ;
100460   Dali::Toolkit::ClampState *arg5 = 0 ;
100461   float result;
100462
100463   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100464   arg2 = (float)jarg2;
100465   arg3 = (float)jarg3;
100466   arg4 = (float)jarg4;
100467   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100468   if (!arg5) {
100469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100470     return 0;
100471   }
100472   {
100473     try {
100474       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100475     } catch (std::out_of_range& e) {
100476       {
100477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100478       };
100479     } catch (std::exception& e) {
100480       {
100481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100482       };
100483     } catch (Dali::DaliException e) {
100484       {
100485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100486       };
100487     } catch (...) {
100488       {
100489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100490       };
100491     }
100492   }
100493
100494   jresult = result;
100495   return jresult;
100496 }
100497
100498
100499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100500   float jresult ;
100501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100502   float arg2 ;
100503   float arg3 ;
100504   float arg4 ;
100505   float arg5 ;
100506   float result;
100507
100508   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100509   arg2 = (float)jarg2;
100510   arg3 = (float)jarg3;
100511   arg4 = (float)jarg4;
100512   arg5 = (float)jarg5;
100513   {
100514     try {
100515       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100516     } catch (std::out_of_range& e) {
100517       {
100518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100519       };
100520     } catch (std::exception& e) {
100521       {
100522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100523       };
100524     } catch (Dali::DaliException e) {
100525       {
100526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100527       };
100528     } catch (...) {
100529       {
100530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100531       };
100532     }
100533   }
100534
100535   jresult = result;
100536   return jresult;
100537 }
100538
100539
100540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100541   float jresult ;
100542   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100543   float arg2 ;
100544   float arg3 ;
100545   float arg4 ;
100546   float result;
100547
100548   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100549   arg2 = (float)jarg2;
100550   arg3 = (float)jarg3;
100551   arg4 = (float)jarg4;
100552   {
100553     try {
100554       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100555     } catch (std::out_of_range& e) {
100556       {
100557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100558       };
100559     } catch (std::exception& e) {
100560       {
100561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100562       };
100563     } catch (Dali::DaliException e) {
100564       {
100565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100566       };
100567     } catch (...) {
100568       {
100569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100570       };
100571     }
100572   }
100573
100574   jresult = result;
100575   return jresult;
100576 }
100577
100578
100579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100580   float jresult ;
100581   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100582   float arg2 ;
100583   float arg3 ;
100584   float result;
100585
100586   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100587   arg2 = (float)jarg2;
100588   arg3 = (float)jarg3;
100589   {
100590     try {
100591       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100592     } catch (std::out_of_range& e) {
100593       {
100594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100595       };
100596     } catch (std::exception& e) {
100597       {
100598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100599       };
100600     } catch (Dali::DaliException e) {
100601       {
100602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100603       };
100604     } catch (...) {
100605       {
100606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100607       };
100608     }
100609   }
100610
100611   jresult = result;
100612   return jresult;
100613 }
100614
100615
100616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100617   float jresult ;
100618   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100619   float arg2 ;
100620   float result;
100621
100622   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100623   arg2 = (float)jarg2;
100624   {
100625     try {
100626       result = (float)(*arg1)->SnapAndClamp(arg2);
100627     } catch (std::out_of_range& e) {
100628       {
100629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100630       };
100631     } catch (std::exception& e) {
100632       {
100633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100634       };
100635     } catch (Dali::DaliException e) {
100636       {
100637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100638       };
100639     } catch (...) {
100640       {
100641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100642       };
100643     }
100644   }
100645
100646   jresult = result;
100647   return jresult;
100648 }
100649
100650
100651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100652   float jresult ;
100653   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100654   float arg2 ;
100655   float arg3 ;
100656   float arg4 ;
100657   float arg5 ;
100658   Dali::Toolkit::ClampState *arg6 = 0 ;
100659   float result;
100660
100661   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100662   arg2 = (float)jarg2;
100663   arg3 = (float)jarg3;
100664   arg4 = (float)jarg4;
100665   arg5 = (float)jarg5;
100666   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100667   if (!arg6) {
100668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100669     return 0;
100670   }
100671   {
100672     try {
100673       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100674     } catch (std::out_of_range& e) {
100675       {
100676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100677       };
100678     } catch (std::exception& e) {
100679       {
100680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100681       };
100682     } catch (Dali::DaliException e) {
100683       {
100684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100685       };
100686     } catch (...) {
100687       {
100688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100689       };
100690     }
100691   }
100692
100693   jresult = result;
100694   return jresult;
100695 }
100696
100697
100698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100699   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100700
100701   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100702   {
100703     try {
100704       (*arg1)->Reference();
100705     } catch (std::out_of_range& e) {
100706       {
100707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100708       };
100709     } catch (std::exception& e) {
100710       {
100711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100712       };
100713     } catch (Dali::DaliException e) {
100714       {
100715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100716       };
100717     } catch (...) {
100718       {
100719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100720       };
100721     }
100722   }
100723
100724 }
100725
100726
100727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100729
100730   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100731   {
100732     try {
100733       (*arg1)->Unreference();
100734     } catch (std::out_of_range& e) {
100735       {
100736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100737       };
100738     } catch (std::exception& e) {
100739       {
100740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100741       };
100742     } catch (Dali::DaliException e) {
100743       {
100744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100745       };
100746     } catch (...) {
100747       {
100748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100749       };
100750     }
100751   }
100752
100753 }
100754
100755
100756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100757   int jresult ;
100758   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100759   int result;
100760
100761   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100762   {
100763     try {
100764       result = (int)(*arg1)->ReferenceCount();
100765     } catch (std::out_of_range& e) {
100766       {
100767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100768       };
100769     } catch (std::exception& e) {
100770       {
100771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100772       };
100773     } catch (Dali::DaliException e) {
100774       {
100775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100776       };
100777     } catch (...) {
100778       {
100779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100780       };
100781     }
100782   }
100783
100784   jresult = result;
100785   return jresult;
100786 }
100787
100788
100789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100790   unsigned int jresult ;
100791   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100792   bool result;
100793
100794   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100795   {
100796     try {
100797       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100798     } catch (std::out_of_range& e) {
100799       {
100800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100801       };
100802     } catch (std::exception& e) {
100803       {
100804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100805       };
100806     } catch (Dali::DaliException e) {
100807       {
100808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100809       };
100810     } catch (...) {
100811       {
100812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100813       };
100814     }
100815   }
100816
100817   jresult = result;
100818   return jresult;
100819 }
100820
100821
100822 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100823   unsigned long jresult ;
100824   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100825   std::size_t result;
100826
100827   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100828   {
100829     try {
100830       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100831     } catch (std::out_of_range& e) {
100832       {
100833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100834       };
100835     } catch (std::exception& e) {
100836       {
100837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100838       };
100839     } catch (Dali::DaliException e) {
100840       {
100841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100842       };
100843     } catch (...) {
100844       {
100845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100846       };
100847     }
100848   }
100849
100850   jresult = (unsigned long)result;
100851   return jresult;
100852 }
100853
100854
100855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100856   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100857   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100858
100859   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100860   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100861   {
100862     try {
100863       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100864     } catch (std::out_of_range& e) {
100865       {
100866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100867       };
100868     } catch (std::exception& e) {
100869       {
100870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100871       };
100872     } catch (Dali::DaliException e) {
100873       {
100874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100875       };
100876     } catch (...) {
100877       {
100878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100879       };
100880     }
100881   }
100882
100883 }
100884
100885
100886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100887   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100888   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100889
100890   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100891   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100892   {
100893     try {
100894       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100895     } catch (std::out_of_range& e) {
100896       {
100897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100898       };
100899     } catch (std::exception& e) {
100900       {
100901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100902       };
100903     } catch (Dali::DaliException e) {
100904       {
100905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100906       };
100907     } catch (...) {
100908       {
100909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100910       };
100911     }
100912   }
100913
100914 }
100915
100916
100917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100918   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100919   Dali::Toolkit::Control arg2 ;
100920   Dali::Toolkit::Control *argp2 ;
100921
100922   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100923   argp2 = (Dali::Toolkit::Control *)jarg2;
100924   if (!argp2) {
100925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100926     return ;
100927   }
100928   arg2 = *argp2;
100929   {
100930     try {
100931       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100932     } catch (std::out_of_range& e) {
100933       {
100934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100935       };
100936     } catch (std::exception& e) {
100937       {
100938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100939       };
100940     } catch (Dali::DaliException e) {
100941       {
100942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100943       };
100944     } catch (...) {
100945       {
100946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100947       };
100948     }
100949   }
100950
100951 }
100952
100953
100954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100955   void * jresult ;
100956   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100957
100958   {
100959     try {
100960       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100961     } catch (std::out_of_range& e) {
100962       {
100963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100964       };
100965     } catch (std::exception& e) {
100966       {
100967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100968       };
100969     } catch (Dali::DaliException e) {
100970       {
100971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100972       };
100973     } catch (...) {
100974       {
100975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100976       };
100977     }
100978   }
100979
100980   jresult = (void *)result;
100981   return jresult;
100982 }
100983
100984
100985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100986   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100987
100988   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100989   {
100990     try {
100991       delete arg1;
100992     } catch (std::out_of_range& e) {
100993       {
100994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100995       };
100996     } catch (std::exception& e) {
100997       {
100998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100999       };
101000     } catch (Dali::DaliException e) {
101001       {
101002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101003       };
101004     } catch (...) {
101005       {
101006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101007       };
101008     }
101009   }
101010
101011 }
101012
101013 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101014   Dali::RefObject *result = NULL;
101015
101016   if (arg1)
101017   {
101018     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101019   }
101020   return result;
101021 }
101022
101023 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101024     return (Dali::RefObject *)jarg1;
101025 }
101026
101027 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101028     return (Dali::SignalObserver *)jarg1;
101029 }
101030
101031 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101032     return (Dali::ConnectionTrackerInterface *)jarg1;
101033 }
101034
101035 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101036     return (Dali::BaseHandle *)jarg1;
101037 }
101038
101039 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101040     return (Dali::BaseHandle *)jarg1;
101041 }
101042
101043 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101044     return (Dali::BaseHandle *)jarg1;
101045 }
101046
101047 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101048     return (Dali::BaseHandle *)jarg1;
101049 }
101050
101051 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101052     return (Dali::BaseHandle *)jarg1;
101053 }
101054
101055 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101056     return (Dali::BaseHandle *)jarg1;
101057 }
101058
101059 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101060     return (Dali::BaseHandle *)jarg1;
101061 }
101062
101063 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101064     return (Dali::BaseHandle *)jarg1;
101065 }
101066
101067 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101068     return (Dali::BaseHandle *)jarg1;
101069 }
101070
101071 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101072     return (Dali::BaseHandle *)jarg1;
101073 }
101074
101075 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101076     return (Dali::BaseHandle *)jarg1;
101077 }
101078
101079 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101080     return (Dali::BaseHandle *)jarg1;
101081 }
101082
101083 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101084     return (Dali::BaseHandle *)jarg1;
101085 }
101086
101087 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101088     return (Dali::Handle *)jarg1;
101089 }
101090
101091 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101092     return (Dali::Handle *)jarg1;
101093 }
101094
101095 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101096     return (Dali::BaseHandle *)jarg1;
101097 }
101098
101099 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101100     return (Dali::BaseHandle *)jarg1;
101101 }
101102
101103 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101104     return (Dali::Handle *)jarg1;
101105 }
101106
101107 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101108     return (Dali::BaseHandle *)jarg1;
101109 }
101110
101111 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101112     return (Dali::Handle *)jarg1;
101113 }
101114
101115 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101116     return (Dali::GestureDetector *)jarg1;
101117 }
101118
101119 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101120     return (Dali::Gesture *)jarg1;
101121 }
101122
101123 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101124     return (Dali::Handle *)jarg1;
101125 }
101126
101127 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101128     return (Dali::Actor *)jarg1;
101129 }
101130
101131 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101132     return (Dali::BaseHandle *)jarg1;
101133 }
101134
101135 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101136     return (Dali::RefObject *)jarg1;
101137 }
101138
101139 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101140     return (Dali::Actor *)jarg1;
101141 }
101142
101143 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101144     return (Dali::GestureDetector *)jarg1;
101145 }
101146
101147 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101148     return (Dali::Gesture *)jarg1;
101149 }
101150
101151 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101152     return (Dali::GestureDetector *)jarg1;
101153 }
101154
101155 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101156     return (Dali::Gesture *)jarg1;
101157 }
101158
101159 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101160     return (Dali::GestureDetector *)jarg1;
101161 }
101162
101163 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101164     return (Dali::Gesture *)jarg1;
101165 }
101166
101167 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101168     return (Dali::BaseHandle *)jarg1;
101169 }
101170
101171 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101172     return (Dali::Handle *)jarg1;
101173 }
101174
101175 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101176     return (Dali::Handle *)jarg1;
101177 }
101178
101179 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101180     return (Dali::Handle *)jarg1;
101181 }
101182
101183 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101184     return (Dali::Image *)jarg1;
101185 }
101186
101187 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101188     return (Dali::Image *)jarg1;
101189 }
101190
101191 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101192     return (Dali::Image *)jarg1;
101193 }
101194
101195 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101196     return (Dali::RefObject *)jarg1;
101197 }
101198
101199 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101200     return (Dali::Image *)jarg1;
101201 }
101202
101203 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101204     return (Dali::Image *)jarg1;
101205 }
101206
101207 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101208     return (Dali::ResourceImage *)jarg1;
101209 }
101210
101211 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101212     return (Dali::Actor *)jarg1;
101213 }
101214
101215 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101216     return (Dali::BaseHandle *)jarg1;
101217 }
101218
101219 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101220     return (Dali::BaseHandle *)jarg1;
101221 }
101222
101223
101224 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101225     return (Dali::BaseHandle *)jarg1;
101226 }
101227
101228 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101229     return (Dali::BaseHandle *)jarg1;
101230 }
101231
101232 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101233     return (Dali::CustomActorImpl *)jarg1;
101234 }
101235
101236 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101237     return (Dali::CustomActor *)jarg1;
101238 }
101239
101240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101241     return (Dali::BaseHandle *)jarg1;
101242 }
101243
101244 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101245     return (Dali::Toolkit::Control *)jarg1;
101246 }
101247
101248 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101249     return (Dali::Toolkit::Control *)jarg1;
101250 }
101251
101252 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101253     return (Dali::Toolkit::Button *)jarg1;
101254 }
101255
101256 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101257     return (Dali::Toolkit::Button *)jarg1;
101258 }
101259
101260 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101261     return (Dali::Toolkit::Button *)jarg1;
101262 }
101263
101264 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101265     return (Dali::Toolkit::Control *)jarg1;
101266 }
101267
101268 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101269     return (Dali::Toolkit::Control *)jarg1;
101270 }
101271
101272 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101273     return (Dali::Toolkit::Control *)jarg1;
101274 }
101275
101276 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101277     return (Dali::Toolkit::Control *)jarg1;
101278 }
101279
101280 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101281     return (Dali::Toolkit::Control *)jarg1;
101282 }
101283
101284 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101285     return (Dali::RefObject *)jarg1;
101286 }
101287
101288 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101289     return (Dali::Toolkit::Scrollable *)jarg1;
101290 }
101291
101292 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101293     return (Dali::BaseHandle *)jarg1;
101294 }
101295
101296 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101297     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101298 }
101299
101300 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101301     return (Dali::RefObject *)jarg1;
101302 }
101303
101304 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101305     return (Dali::Toolkit::Ruler *)jarg1;
101306 }
101307
101308 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101309     return (Dali::Toolkit::Ruler *)jarg1;
101310 }
101311
101312 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101313     return (Dali::Toolkit::Scrollable *)jarg1;
101314 }
101315
101316 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101317     return (Dali::Toolkit::Control *)jarg1;
101318 }
101319
101320
101321 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101322     return (Dali::Toolkit::Control *)jarg1;
101323 }
101324
101325 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101326     return (Dali::BaseHandle *)jarg1;
101327 }
101328
101329 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101330     return (Dali::BaseHandle *)jarg1;
101331 }
101332
101333 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101334     return (Dali::Toolkit::Control *)jarg1;
101335 }
101336
101337 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101338     return (Dali::Toolkit::Control *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101342     return (Dali::Toolkit::Control *)jarg1;
101343 }
101344
101345 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101346     return (Dali::Toolkit::Control *)jarg1;
101347 }
101348
101349 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101350     return (Dali::Toolkit::Control *)jarg1;
101351 }
101352
101353 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101354     return (Dali::Toolkit::Control *)jarg1;
101355 }
101356
101357 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101358     return (Dali::Toolkit::PageTurnView *)jarg1;
101359 }
101360
101361 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101362     return (Dali::Toolkit::PageTurnView *)jarg1;
101363 }
101364
101365 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101366     return (Dali::Toolkit::Button *)jarg1;
101367 }
101368
101369 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101370     return (Dali::BaseHandle *)jarg1;
101371 }
101372
101373 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101374     return (Dali::BaseHandle *)jarg1;
101375 }
101376
101377 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101378     return (Dali::BaseHandle *)jarg1;
101379 }
101380
101381 /*
101382  * Widget binding
101383  */
101384 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101385     return (Dali::BaseHandle *)jarg1;
101386 }
101387
101388 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101389     return (Dali::BaseObject *)jarg1;
101390 }
101391
101392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101393   void * jresult ;
101394   Dali::Widget result;
101395
101396   {
101397     try {
101398       result = Dali::Widget::New();
101399     } catch (std::out_of_range& e) {
101400       {
101401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101402       };
101403     } catch (std::exception& e) {
101404       {
101405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101406       };
101407     } catch (...) {
101408       {
101409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101410       };
101411     }
101412   }
101413   jresult = new Dali::Widget((const Dali::Widget &)result);
101414   return jresult;
101415 }
101416
101417
101418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101419   void * jresult ;
101420   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101421   Dali::Widget result;
101422
101423   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101424
101425   if (!arg1) {
101426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101427     return 0;
101428   }
101429   {
101430     try {
101431       jresult = new Dali::Widget(arg1);
101432     } catch (std::out_of_range& e) {
101433       {
101434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101435       };
101436     } catch (std::exception& e) {
101437       {
101438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101439       };
101440     } catch (...) {
101441       {
101442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101443       };
101444     }
101445   }
101446   return jresult;
101447 }
101448
101449
101450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101451   void * jresult ;
101452   Dali::Widget *result = 0 ;
101453
101454   {
101455     try {
101456       result = (Dali::Widget *)new Dali::Widget();
101457     } catch (std::out_of_range& e) {
101458       {
101459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101460       };
101461     } catch (std::exception& e) {
101462       {
101463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101464       };
101465     } catch (...) {
101466       {
101467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101468       };
101469     }
101470   }
101471   jresult = (void *)result;
101472   return jresult;
101473 }
101474
101475
101476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101477   void * jresult ;
101478   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101479   Dali::Widget *arg2 = 0 ;
101480   Dali::Widget *result = 0 ;
101481
101482   arg1 = (Dali::Widget *)jarg1;
101483   arg2 = (Dali::Widget *)jarg2;
101484   if (!arg2) {
101485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101486     return 0;
101487   }
101488   {
101489     try {
101490       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101491     } catch (std::out_of_range& e) {
101492       {
101493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101494       };
101495     } catch (std::exception& e) {
101496       {
101497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101498       };
101499     } catch (...) {
101500       {
101501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101502       };
101503     }
101504   }
101505   jresult = (void *)result;
101506   return jresult;
101507 }
101508
101509
101510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101511   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101512
101513   arg1 = (Dali::Widget *)jarg1;
101514   {
101515     try {
101516       delete arg1;
101517     } catch (std::out_of_range& e) {
101518       {
101519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101520       };
101521     } catch (std::exception& e) {
101522       {
101523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101524       };
101525     } catch (...) {
101526       {
101527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101528       };
101529     }
101530   }
101531 }
101532
101533
101534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101535   void * jresult ;
101536   SwigDirector_WidgetImpl* result;
101537   {
101538     try {
101539       result = new SwigDirector_WidgetImpl();
101540     } catch (std::out_of_range& e) {
101541       {
101542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101543       };
101544     } catch (std::exception& e) {
101545       {
101546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101547       };
101548     } catch (...) {
101549       {
101550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101551       };
101552     }
101553   }
101554   jresult = result;
101555   return jresult;
101556 }
101557
101558
101559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101560   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101561   std::string *arg2 = 0 ;
101562   Dali::Window arg3 ;
101563   Dali::Window *argp3 ;
101564
101565   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101566   if (!jarg2) {
101567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101568     return ;
101569   }
101570   std::string arg2_str(jarg2);
101571   arg2 = &arg2_str;
101572   argp3 = (Dali::Window *)jarg3;
101573   if (!argp3) {
101574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101575     return ;
101576   }
101577   arg3 = *argp3;
101578   {
101579     try {
101580       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101581     } catch (std::out_of_range& e) {
101582       {
101583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101584       };
101585     } catch (std::exception& e) {
101586       {
101587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101588       };
101589     } catch (...) {
101590       {
101591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101592       };
101593     }
101594   }
101595 }
101596
101597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101598   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101599   std::string *arg2 = 0 ;
101600   Dali::Window arg3 ;
101601   Dali::Window *argp3 ;
101602
101603   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101604   if (!jarg2) {
101605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101606     return ;
101607   }
101608   std::string arg2_str(jarg2);
101609   arg2 = &arg2_str;
101610   argp3 = (Dali::Window *)jarg3;
101611   if (!argp3) {
101612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101613     return ;
101614   }
101615   arg3 = *argp3;
101616   {
101617     try {
101618       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101619     } catch (std::out_of_range& e) {
101620       {
101621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101622       };
101623     } catch (std::exception& e) {
101624       {
101625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101626       };
101627     } catch (...) {
101628       {
101629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101630       };
101631     }
101632   }
101633 }
101634
101635
101636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101637   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101638   std::string *arg2 = 0 ;
101639   Dali::Widget::Termination arg3 ;
101640
101641   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101642   if (!jarg2) {
101643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101644     return ;
101645   }
101646   std::string arg2_str(jarg2);
101647   arg2 = &arg2_str;
101648   arg3 = (Dali::Widget::Termination)jarg3;
101649   {
101650     try {
101651       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101652     } catch (std::out_of_range& e) {
101653       {
101654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101655       };
101656     } catch (std::exception& e) {
101657       {
101658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101659       };
101660     } catch (...) {
101661       {
101662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101663       };
101664     }
101665   }
101666 }
101667
101668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101669   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101670   std::string *arg2 = 0 ;
101671   Dali::Widget::Termination arg3 ;
101672
101673   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101674   if (!jarg2) {
101675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101676     return ;
101677   }
101678   std::string arg2_str(jarg2);
101679   arg2 = &arg2_str;
101680   arg3 = (Dali::Widget::Termination)jarg3;
101681   {
101682     try {
101683       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101684     } catch (std::out_of_range& e) {
101685       {
101686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101687       };
101688     } catch (std::exception& e) {
101689       {
101690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101691       };
101692     } catch (...) {
101693       {
101694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101695       };
101696     }
101697   }
101698 }
101699
101700
101701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101702   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101703
101704   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101705   {
101706     try {
101707       (arg1)->OnPause();
101708     } catch (std::out_of_range& e) {
101709       {
101710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101711       };
101712     } catch (std::exception& e) {
101713       {
101714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101715       };
101716     } catch (...) {
101717       {
101718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101719       };
101720     }
101721   }
101722 }
101723
101724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101725   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101726
101727   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101728   {
101729     try {
101730       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101731     } catch (std::out_of_range& e) {
101732       {
101733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101734       };
101735     } catch (std::exception& e) {
101736       {
101737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101738       };
101739     } catch (...) {
101740       {
101741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101742       };
101743     }
101744   }
101745 }
101746
101747
101748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101749   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101750
101751   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101752   {
101753     try {
101754       (arg1)->OnResume();
101755     } catch (std::out_of_range& e) {
101756       {
101757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101758       };
101759     } catch (std::exception& e) {
101760       {
101761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101762       };
101763     } catch (...) {
101764       {
101765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101766       };
101767     }
101768   }
101769 }
101770
101771
101772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101773   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101774
101775   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101776   {
101777     try {
101778       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101779     } catch (std::out_of_range& e) {
101780       {
101781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101782       };
101783     } catch (std::exception& e) {
101784       {
101785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101786       };
101787     } catch (...) {
101788       {
101789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101790       };
101791     }
101792   }
101793 }
101794
101795
101796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101797   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101798   Dali::Window arg2 ;
101799   Dali::Window *argp2 ;
101800
101801   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101802   argp2 = (Dali::Window *)jarg2;
101803   if (!argp2) {
101804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101805     return ;
101806   }
101807   arg2 = *argp2;
101808   {
101809     try {
101810       (arg1)->OnResize(arg2);
101811     } catch (std::out_of_range& e) {
101812       {
101813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101814       };
101815     } catch (std::exception& e) {
101816       {
101817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101818       };
101819     } catch (...) {
101820       {
101821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101822       };
101823     }
101824   }
101825 }
101826
101827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101828   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101829   Dali::Window arg2 ;
101830   Dali::Window *argp2 ;
101831
101832   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101833   argp2 = (Dali::Window *)jarg2;
101834   if (!argp2) {
101835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101836     return ;
101837   }
101838   arg2 = *argp2;
101839   {
101840     try {
101841       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101842     } catch (std::out_of_range& e) {
101843       {
101844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101845       };
101846     } catch (std::exception& e) {
101847       {
101848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101849       };
101850     } catch (...) {
101851       {
101852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101853       };
101854     }
101855   }
101856 }
101857
101858
101859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101860   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101861   std::string *arg2 = 0 ;
101862   int arg3 ;
101863
101864   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101865   if (!jarg2) {
101866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101867     return ;
101868   }
101869   std::string arg2_str(jarg2);
101870   arg2 = &arg2_str;
101871   arg3 = (int)jarg3;
101872   {
101873     try {
101874       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101875     } catch (std::out_of_range& e) {
101876       {
101877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101878       };
101879     } catch (std::exception& e) {
101880       {
101881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101882       };
101883     } catch (...) {
101884       {
101885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101886       };
101887     }
101888   }
101889 }
101890
101891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101892   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101893   std::string *arg2 = 0 ;
101894   int arg3 ;
101895
101896   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101897   if (!jarg2) {
101898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101899     return ;
101900   }
101901   std::string arg2_str(jarg2);
101902   arg2 = &arg2_str;
101903   arg3 = (int)jarg3;
101904   {
101905     try {
101906       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101907     } catch (std::out_of_range& e) {
101908       {
101909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101910       };
101911     } catch (std::exception& e) {
101912       {
101913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101914       };
101915     } catch (...) {
101916       {
101917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101918       };
101919     }
101920   }
101921 }
101922
101923
101924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101925   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101926   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101927   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101928
101929   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101930   arg2 = (Dali::SlotObserver *)jarg2;
101931   arg3 = (Dali::CallbackBase *)jarg3;
101932   {
101933     try {
101934       (arg1)->SignalConnected(arg2,arg3);
101935     } catch (std::out_of_range& e) {
101936       {
101937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101938       };
101939     } catch (std::exception& e) {
101940       {
101941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101942       };
101943     } catch (...) {
101944       {
101945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101946       };
101947     }
101948   }
101949 }
101950
101951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101952   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101953   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101954   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101955
101956   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101957   arg2 = (Dali::SlotObserver *)jarg2;
101958   arg3 = (Dali::CallbackBase *)jarg3;
101959   {
101960     try {
101961       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101962     } catch (std::out_of_range& e) {
101963       {
101964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101965       };
101966     } catch (std::exception& e) {
101967       {
101968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101969       };
101970     } catch (...) {
101971       {
101972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101973       };
101974     }
101975   }
101976 }
101977
101978
101979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101980   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101981   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101982   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101983
101984   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101985   arg2 = (Dali::SlotObserver *)jarg2;
101986   arg3 = (Dali::CallbackBase *)jarg3;
101987   {
101988     try {
101989       (arg1)->SignalDisconnected(arg2,arg3);
101990     } catch (std::out_of_range& e) {
101991       {
101992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101993       };
101994     } catch (std::exception& e) {
101995       {
101996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101997       };
101998     } catch (...) {
101999       {
102000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102001       };
102002     }
102003   }
102004 }
102005
102006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102007   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102008   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102009   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102010
102011   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102012   arg2 = (Dali::SlotObserver *)jarg2;
102013   arg3 = (Dali::CallbackBase *)jarg3;
102014   {
102015     try {
102016       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102017     } catch (std::out_of_range& e) {
102018       {
102019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102020       };
102021     } catch (std::exception& e) {
102022       {
102023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102024       };
102025     } catch (...) {
102026       {
102027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102028       };
102029     }
102030   }
102031 }
102032
102033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102034   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102035   std::string *arg2 = 0 ;
102036
102037   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102038   if (!jarg2) {
102039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102040     return ;
102041   }
102042   std::string arg2_str(jarg2);
102043   arg2 = &arg2_str;
102044   {
102045     try {
102046       (arg1)->SetContentInfo((std::string const &)*arg2);
102047     } catch (std::out_of_range& e) {
102048       {
102049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102050       };
102051     } catch (std::exception& e) {
102052       {
102053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102054       };
102055     } catch (...) {
102056       {
102057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102058       };
102059     }
102060   }
102061 }
102062
102063
102064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102065   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102066   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102067
102068   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102069   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102070   {
102071     try {
102072       (arg1)->SetImpl(arg2);
102073     } catch (std::out_of_range& e) {
102074       {
102075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102076       };
102077     } catch (std::exception& e) {
102078       {
102079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102080       };
102081     } catch (...) {
102082       {
102083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102084       };
102085     }
102086   }
102087 }
102088
102089 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) {
102090
102091   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102092   if (director) {
102093     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102094   }
102095 }
102096
102097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102098   void * jresult ;
102099   Dali::Widget *arg1 = 0 ;
102100   SwigDirector_WidgetImpl *result = 0 ;
102101
102102   arg1 = (Dali::Widget *)jarg1;
102103   if (!arg1) {
102104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102105     return 0;
102106   }
102107   {
102108     try {
102109       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102110     } catch (std::out_of_range& e) {
102111       {
102112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102113       };
102114     } catch (std::exception& e) {
102115       {
102116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102117       };
102118     } catch (...) {
102119       {
102120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102121       };
102122     }
102123   }
102124
102125   jresult = (void *)result;
102126   return jresult;
102127 }
102128
102129
102130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102131   void * jresult ;
102132   int *arg1 = (int *) 0 ;
102133   char ***arg2 ;
102134   std::string *arg3 = 0 ;
102135   Dali::WidgetApplication result;
102136   {
102137     int index = 0;
102138     int length = 0;
102139     char *retPtr;
102140     char *nextPtr;
102141     argWidgetC = jarg1;
102142     argWidgetV = new char*[jarg1 + 1];
102143
102144     retPtr = strtok_r( jarg2, " ", &nextPtr);
102145     if( retPtr )
102146     {
102147       length = strlen(retPtr);
102148     }
102149     argWidgetV[index] = new char[length + 1];
102150     if( retPtr )
102151     {
102152       strncpy(argWidgetV[index], retPtr, length);
102153     }
102154     argWidgetV[index][length] = '\0';
102155     index++;
102156
102157     while (index < jarg1)
102158     {
102159       length = 0;
102160       retPtr = strtok_r(NULL, " ", &nextPtr);
102161       if( retPtr )
102162       {
102163         length = strlen(retPtr);
102164       }
102165       argWidgetV[index] = new char[length + 1];
102166       if( retPtr )
102167       {
102168         strncpy(argWidgetV[index], retPtr, length);
102169       }
102170       argWidgetV[index][length] = '\0';
102171       index++;
102172     }
102173
102174     argWidgetV[jarg1] = NULL;
102175     argWidgetC = jarg1;
102176
102177     arg1 = &argWidgetC;
102178     arg2 = &argWidgetV;
102179   }
102180
102181   if (!jarg3) {
102182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102183     return 0;
102184   }
102185   std::string arg3_str(jarg3);
102186   arg3 = &arg3_str;
102187   {
102188     try {
102189       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102190     } catch (std::out_of_range& e) {
102191       {
102192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102193       };
102194     } catch (std::exception& e) {
102195       {
102196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102197       };
102198     } catch (...) {
102199       {
102200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102201       };
102202     }
102203   }
102204   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102205
102206   return jresult;
102207 }
102208
102209
102210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102211   void * jresult ;
102212   Dali::WidgetApplication *result = 0 ;
102213
102214   {
102215     try {
102216       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102217     } catch (std::out_of_range& e) {
102218       {
102219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102220       };
102221     } catch (std::exception& e) {
102222       {
102223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102224       };
102225     } catch (...) {
102226       {
102227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102228       };
102229     }
102230   }
102231   jresult = (void *)result;
102232   return jresult;
102233 }
102234
102235
102236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102237   void * jresult ;
102238   Dali::WidgetApplication *arg1 = 0 ;
102239   Dali::WidgetApplication *result = 0 ;
102240
102241   arg1 = (Dali::WidgetApplication *)jarg1;
102242   if (!arg1) {
102243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102244     return 0;
102245   }
102246   {
102247     try {
102248       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102249     } catch (std::out_of_range& e) {
102250       {
102251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102252       };
102253     } catch (std::exception& e) {
102254       {
102255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102256       };
102257     } catch (...) {
102258       {
102259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102260       };
102261     }
102262   }
102263   jresult = (void *)result;
102264   return jresult;
102265 }
102266
102267
102268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102269   void * jresult ;
102270   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102271   Dali::WidgetApplication *arg2 = 0 ;
102272   Dali::WidgetApplication *result = 0 ;
102273
102274   arg1 = (Dali::WidgetApplication *)jarg1;
102275   arg2 = (Dali::WidgetApplication *)jarg2;
102276   if (!arg2) {
102277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102278     return 0;
102279   }
102280   {
102281     try {
102282       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102283     } catch (std::out_of_range& e) {
102284       {
102285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102286       };
102287     } catch (std::exception& e) {
102288       {
102289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102290       };
102291     } catch (...) {
102292       {
102293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102294       };
102295     }
102296   }
102297   jresult = (void *)result;
102298   return jresult;
102299 }
102300
102301
102302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102303   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102304
102305   arg1 = (Dali::WidgetApplication *)jarg1;
102306   {
102307     try {
102308       delete arg1;
102309       if( argWidgetV )
102310       {
102311         // free string data
102312         for( int i=0; i < argWidgetC+1; i++)
102313         {
102314           delete [] argWidgetV[i];
102315         }
102316         delete [] argWidgetV;
102317       }
102318     } catch (std::out_of_range& e) {
102319       {
102320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102321       };
102322     } catch (std::exception& e) {
102323       {
102324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102325       };
102326     } catch (...) {
102327       {
102328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102329       };
102330     }
102331   }
102332 }
102333
102334
102335 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102336 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102337
102338 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102339 {
102340   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102341   return *widget;
102342 }
102343
102344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102345   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102346   std::string *arg2 = 0 ;
102347
102348   arg1 = (Dali::WidgetApplication *)jarg1;
102349   if (!jarg2) {
102350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102351     return ;
102352   }
102353   std::string arg2_str(*jarg2);
102354   arg2 = &arg2_str;
102355
102356   if(!_CSharpCreateWidgetFunction)
102357   {
102358     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102359   }
102360
102361   {
102362     try {
102363       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102364     } catch (std::out_of_range& e) {
102365       {
102366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102367       };
102368     } catch (std::exception& e) {
102369       {
102370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102371       };
102372     } catch (...) {
102373       {
102374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102375       };
102376     }
102377   }
102378
102379   //Typemap argout in c++ file.
102380   //This will convert c++ string to c# string
102381   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102382 }
102383
102384
102385 //for PixelBuffer and ImageLoading
102386
102387 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102388     return (Dali::BaseHandle *)jarg1;
102389 }
102390
102391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102392   void * jresult ;
102393   unsigned int arg1 ;
102394   unsigned int arg2 ;
102395   Dali::Pixel::Format arg3 ;
102396   Dali::Devel::PixelBuffer result;
102397
102398   arg1 = (unsigned int)jarg1;
102399   arg2 = (unsigned int)jarg2;
102400   arg3 = (Dali::Pixel::Format)jarg3;
102401   {
102402     try {
102403       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102404     } catch (std::out_of_range& e) {
102405       {
102406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102407       };
102408     } catch (std::exception& e) {
102409       {
102410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102411       };
102412     } catch (...) {
102413       {
102414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102415       };
102416     }
102417   }
102418   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102419   return jresult;
102420 }
102421
102422
102423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102424   void * jresult ;
102425   Dali::Devel::PixelBuffer *result = 0 ;
102426
102427   {
102428     try {
102429       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102430     } catch (std::out_of_range& e) {
102431       {
102432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102433       };
102434     } catch (std::exception& e) {
102435       {
102436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102437       };
102438     } catch (...) {
102439       {
102440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102441       };
102442     }
102443   }
102444   jresult = (void *)result;
102445   return jresult;
102446 }
102447
102448
102449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102450   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102451
102452   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102453   {
102454     try {
102455       delete arg1;
102456     } catch (std::out_of_range& e) {
102457       {
102458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102459       };
102460     } catch (std::exception& e) {
102461       {
102462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102463       };
102464     } catch (...) {
102465       {
102466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102467       };
102468     }
102469   }
102470 }
102471
102472
102473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102474   void * jresult ;
102475   Dali::Devel::PixelBuffer *arg1 = 0 ;
102476   Dali::Devel::PixelBuffer *result = 0 ;
102477
102478   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102479   if (!arg1) {
102480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102481     return 0;
102482   }
102483   {
102484     try {
102485       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102486     } catch (std::out_of_range& e) {
102487       {
102488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102489       };
102490     } catch (std::exception& e) {
102491       {
102492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102493       };
102494     } catch (...) {
102495       {
102496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102497       };
102498     }
102499   }
102500   jresult = (void *)result;
102501   return jresult;
102502 }
102503
102504
102505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102506   void * jresult ;
102507   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102508   Dali::Devel::PixelBuffer *arg2 = 0 ;
102509   Dali::Devel::PixelBuffer *result = 0 ;
102510
102511   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102512   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102513   if (!arg2) {
102514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102515     return 0;
102516   }
102517   {
102518     try {
102519       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102520     } catch (std::out_of_range& e) {
102521       {
102522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102523       };
102524     } catch (std::exception& e) {
102525       {
102526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102527       };
102528     } catch (...) {
102529       {
102530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102531       };
102532     }
102533   }
102534   jresult = (void *)result;
102535   return jresult;
102536 }
102537
102538
102539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102540   void * jresult ;
102541   Dali::Devel::PixelBuffer *arg1 = 0 ;
102542   Dali::PixelData result;
102543
102544   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102545   if (!arg1) {
102546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102547     return 0;
102548   }
102549   {
102550     try {
102551       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102552     } catch (std::out_of_range& e) {
102553       {
102554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102555       };
102556     } catch (std::exception& e) {
102557       {
102558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102559       };
102560     } catch (...) {
102561       {
102562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102563       };
102564     }
102565   }
102566   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102567   return jresult;
102568 }
102569
102570
102571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102572   void * jresult ;
102573   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102574   Dali::PixelData result;
102575
102576   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102577   {
102578     try {
102579       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102580     } catch (std::out_of_range& e) {
102581       {
102582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102583       };
102584     } catch (std::exception& e) {
102585       {
102586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102587       };
102588     } catch (...) {
102589       {
102590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102591       };
102592     }
102593   }
102594   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102595   return jresult;
102596 }
102597
102598
102599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102600   void * jresult ;
102601   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102602   unsigned char *result = 0 ;
102603
102604   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102605   {
102606     try {
102607       result = (unsigned char *)(arg1)->GetBuffer();
102608     } catch (std::out_of_range& e) {
102609       {
102610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102611       };
102612     } catch (std::exception& e) {
102613       {
102614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102615       };
102616     } catch (...) {
102617       {
102618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102619       };
102620     }
102621   }
102622   jresult = (void *)result;
102623   return jresult;
102624 }
102625
102626
102627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102628   unsigned int jresult ;
102629   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102630   unsigned int result;
102631
102632   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102633   {
102634     try {
102635       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102636     } catch (std::out_of_range& e) {
102637       {
102638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102639       };
102640     } catch (std::exception& e) {
102641       {
102642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102643       };
102644     } catch (...) {
102645       {
102646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102647       };
102648     }
102649   }
102650   jresult = result;
102651   return jresult;
102652 }
102653
102654
102655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102656   unsigned int jresult ;
102657   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102658   unsigned int result;
102659
102660   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102661   {
102662     try {
102663       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102664     } catch (std::out_of_range& e) {
102665       {
102666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102667       };
102668     } catch (std::exception& e) {
102669       {
102670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102671       };
102672     } catch (...) {
102673       {
102674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102675       };
102676     }
102677   }
102678   jresult = result;
102679   return jresult;
102680 }
102681
102682
102683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102684   int jresult ;
102685   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102686   Dali::Pixel::Format result;
102687
102688   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102689   {
102690     try {
102691       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102692     } catch (std::out_of_range& e) {
102693       {
102694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102695       };
102696     } catch (std::exception& e) {
102697       {
102698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102699       };
102700     } catch (...) {
102701       {
102702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102703       };
102704     }
102705   }
102706   jresult = (int)result;
102707   return jresult;
102708 }
102709
102710
102711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102712   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102713   Dali::Devel::PixelBuffer arg2 ;
102714   float arg3 ;
102715   bool arg4 ;
102716   Dali::Devel::PixelBuffer *argp2 ;
102717
102718   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102719   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102720   if (!argp2) {
102721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102722     return ;
102723   }
102724   arg2 = *argp2;
102725   arg3 = (float)jarg3;
102726   arg4 = jarg4 ? true : false;
102727   {
102728     try {
102729       (arg1)->ApplyMask(arg2,arg3,arg4);
102730     } catch (std::out_of_range& e) {
102731       {
102732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102733       };
102734     } catch (std::exception& e) {
102735       {
102736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102737       };
102738     } catch (...) {
102739       {
102740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102741       };
102742     }
102743   }
102744 }
102745
102746
102747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102748   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102749   Dali::Devel::PixelBuffer arg2 ;
102750   float arg3 ;
102751   Dali::Devel::PixelBuffer *argp2 ;
102752
102753   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102754   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102755   if (!argp2) {
102756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102757     return ;
102758   }
102759   arg2 = *argp2;
102760   arg3 = (float)jarg3;
102761   {
102762     try {
102763       (arg1)->ApplyMask(arg2,arg3);
102764     } catch (std::out_of_range& e) {
102765       {
102766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102767       };
102768     } catch (std::exception& e) {
102769       {
102770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102771       };
102772     } catch (...) {
102773       {
102774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102775       };
102776     }
102777   }
102778 }
102779
102780
102781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102782   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102783   Dali::Devel::PixelBuffer arg2 ;
102784   Dali::Devel::PixelBuffer *argp2 ;
102785
102786   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102787   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102788   if (!argp2) {
102789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102790     return ;
102791   }
102792   arg2 = *argp2;
102793   {
102794     try {
102795       (arg1)->ApplyMask(arg2);
102796     } catch (std::out_of_range& e) {
102797       {
102798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102799       };
102800     } catch (std::exception& e) {
102801       {
102802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102803       };
102804     } catch (...) {
102805       {
102806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102807       };
102808     }
102809   }
102810 }
102811
102812
102813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102814   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102815   float arg2 ;
102816
102817   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102818   arg2 = (float)jarg2;
102819   {
102820     try {
102821       (arg1)->ApplyGaussianBlur(arg2);
102822     } catch (std::out_of_range& e) {
102823       {
102824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102825       };
102826     } catch (std::exception& e) {
102827       {
102828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102829       };
102830     } catch (...) {
102831       {
102832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102833       };
102834     }
102835   }
102836 }
102837
102838
102839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102840   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102841   uint16_t arg2 ;
102842   uint16_t arg3 ;
102843   uint16_t arg4 ;
102844   uint16_t arg5 ;
102845
102846   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102847   arg2 = (uint16_t)jarg2;
102848   arg3 = (uint16_t)jarg3;
102849   arg4 = (uint16_t)jarg4;
102850   arg5 = (uint16_t)jarg5;
102851   {
102852     try {
102853       (arg1)->Crop(arg2,arg3,arg4,arg5);
102854     } catch (std::out_of_range& e) {
102855       {
102856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102857       };
102858     } catch (std::exception& e) {
102859       {
102860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102861       };
102862     } catch (...) {
102863       {
102864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102865       };
102866     }
102867   }
102868 }
102869
102870
102871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102872   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102873   uint16_t arg2 ;
102874   uint16_t arg3 ;
102875
102876   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102877   arg2 = (uint16_t)jarg2;
102878   arg3 = (uint16_t)jarg3;
102879   {
102880     try {
102881       (arg1)->Resize(arg2,arg3);
102882     } catch (std::out_of_range& e) {
102883       {
102884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102885       };
102886     } catch (std::exception& e) {
102887       {
102888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102889       };
102890     } catch (...) {
102891       {
102892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102893       };
102894     }
102895   }
102896 }
102897
102898
102899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102900   void * jresult ;
102901   std::string *arg1 = 0 ;
102902   Dali::ImageDimensions arg2 ;
102903   Dali::FittingMode::Type arg3 ;
102904   Dali::SamplingMode::Type arg4 ;
102905   bool arg5 ;
102906   Dali::ImageDimensions *argp2 ;
102907   Dali::Devel::PixelBuffer result;
102908
102909   if (!jarg1) {
102910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102911     return 0;
102912   }
102913   std::string arg1_str(jarg1);
102914   arg1 = &arg1_str;
102915   argp2 = (Dali::ImageDimensions *)jarg2;
102916   if (!argp2) {
102917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102918     return 0;
102919   }
102920   arg2 = *argp2;
102921   arg3 = (Dali::FittingMode::Type)jarg3;
102922   arg4 = (Dali::SamplingMode::Type)jarg4;
102923   arg5 = jarg5 ? true : false;
102924   {
102925     try {
102926       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102927     } catch (std::out_of_range& e) {
102928       {
102929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102930       };
102931     } catch (std::exception& e) {
102932       {
102933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102934       };
102935     } catch (...) {
102936       {
102937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102938       };
102939     }
102940   }
102941   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102942
102943   return jresult;
102944 }
102945
102946
102947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102948   void * jresult ;
102949   std::string *arg1 = 0 ;
102950   Dali::ImageDimensions arg2 ;
102951   Dali::FittingMode::Type arg3 ;
102952   Dali::SamplingMode::Type arg4 ;
102953   Dali::ImageDimensions *argp2 ;
102954   Dali::Devel::PixelBuffer result;
102955
102956   if (!jarg1) {
102957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102958     return 0;
102959   }
102960   std::string arg1_str(jarg1);
102961   arg1 = &arg1_str;
102962   argp2 = (Dali::ImageDimensions *)jarg2;
102963   if (!argp2) {
102964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102965     return 0;
102966   }
102967   arg2 = *argp2;
102968   arg3 = (Dali::FittingMode::Type)jarg3;
102969   arg4 = (Dali::SamplingMode::Type)jarg4;
102970   {
102971     try {
102972       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102973     } catch (std::out_of_range& e) {
102974       {
102975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102976       };
102977     } catch (std::exception& e) {
102978       {
102979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102980       };
102981     } catch (...) {
102982       {
102983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102984       };
102985     }
102986   }
102987   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102988
102989   return jresult;
102990 }
102991
102992
102993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102994   void * jresult ;
102995   std::string *arg1 = 0 ;
102996   Dali::ImageDimensions arg2 ;
102997   Dali::FittingMode::Type arg3 ;
102998   Dali::ImageDimensions *argp2 ;
102999   Dali::Devel::PixelBuffer 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   arg3 = (Dali::FittingMode::Type)jarg3;
103014   {
103015     try {
103016       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103017     } catch (std::out_of_range& e) {
103018       {
103019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103020       };
103021     } catch (std::exception& e) {
103022       {
103023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103024       };
103025     } catch (...) {
103026       {
103027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103028       };
103029     }
103030   }
103031   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103032
103033   return jresult;
103034 }
103035
103036
103037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103038   void * jresult ;
103039   std::string *arg1 = 0 ;
103040   Dali::ImageDimensions arg2 ;
103041   Dali::ImageDimensions *argp2 ;
103042   Dali::Devel::PixelBuffer result;
103043
103044   if (!jarg1) {
103045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103046     return 0;
103047   }
103048   std::string arg1_str(jarg1);
103049   arg1 = &arg1_str;
103050   argp2 = (Dali::ImageDimensions *)jarg2;
103051   if (!argp2) {
103052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103053     return 0;
103054   }
103055   arg2 = *argp2;
103056   {
103057     try {
103058       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103059     } catch (std::out_of_range& e) {
103060       {
103061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103062       };
103063     } catch (std::exception& e) {
103064       {
103065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103066       };
103067     } catch (...) {
103068       {
103069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103070       };
103071     }
103072   }
103073   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103074
103075   return jresult;
103076 }
103077
103078
103079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103080   void * jresult ;
103081   std::string *arg1 = 0 ;
103082   Dali::Devel::PixelBuffer result;
103083
103084   if (!jarg1) {
103085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103086     return 0;
103087   }
103088   std::string arg1_str(jarg1);
103089   arg1 = &arg1_str;
103090   {
103091     try {
103092       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103093     } catch (std::out_of_range& e) {
103094       {
103095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103096       };
103097     } catch (std::exception& e) {
103098       {
103099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103100       };
103101     } catch (...) {
103102       {
103103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103104       };
103105     }
103106   }
103107   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103108
103109   return jresult;
103110 }
103111
103112
103113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103114   void * jresult ;
103115   std::string *arg1 = 0 ;
103116   Dali::ImageDimensions arg2 ;
103117   Dali::FittingMode::Type arg3 ;
103118   Dali::SamplingMode::Type arg4 ;
103119   bool arg5 ;
103120   Dali::ImageDimensions *argp2 ;
103121   Dali::ImageDimensions result;
103122
103123   if (!jarg1) {
103124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103125     return 0;
103126   }
103127   std::string arg1_str(jarg1);
103128   arg1 = &arg1_str;
103129   argp2 = (Dali::ImageDimensions *)jarg2;
103130   if (!argp2) {
103131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103132     return 0;
103133   }
103134   arg2 = *argp2;
103135   arg3 = (Dali::FittingMode::Type)jarg3;
103136   arg4 = (Dali::SamplingMode::Type)jarg4;
103137   arg5 = jarg5 ? true : false;
103138   {
103139     try {
103140       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103141     } catch (std::out_of_range& e) {
103142       {
103143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103144       };
103145     } catch (std::exception& e) {
103146       {
103147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103148       };
103149     } catch (...) {
103150       {
103151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103152       };
103153     }
103154   }
103155   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103156
103157   return jresult;
103158 }
103159
103160
103161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103162   void * jresult ;
103163   std::string *arg1 = 0 ;
103164   Dali::ImageDimensions arg2 ;
103165   Dali::FittingMode::Type arg3 ;
103166   Dali::SamplingMode::Type arg4 ;
103167   Dali::ImageDimensions *argp2 ;
103168   Dali::ImageDimensions result;
103169
103170   if (!jarg1) {
103171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103172     return 0;
103173   }
103174   std::string arg1_str(jarg1);
103175   arg1 = &arg1_str;
103176   argp2 = (Dali::ImageDimensions *)jarg2;
103177   if (!argp2) {
103178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103179     return 0;
103180   }
103181   arg2 = *argp2;
103182   arg3 = (Dali::FittingMode::Type)jarg3;
103183   arg4 = (Dali::SamplingMode::Type)jarg4;
103184   {
103185     try {
103186       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103187     } catch (std::out_of_range& e) {
103188       {
103189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103190       };
103191     } catch (std::exception& e) {
103192       {
103193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103194       };
103195     } catch (...) {
103196       {
103197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103198       };
103199     }
103200   }
103201   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103202
103203   return jresult;
103204 }
103205
103206
103207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103208   void * jresult ;
103209   std::string *arg1 = 0 ;
103210   Dali::ImageDimensions arg2 ;
103211   Dali::FittingMode::Type arg3 ;
103212   Dali::ImageDimensions *argp2 ;
103213   Dali::ImageDimensions result;
103214
103215   if (!jarg1) {
103216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103217     return 0;
103218   }
103219   std::string arg1_str(jarg1);
103220   arg1 = &arg1_str;
103221   argp2 = (Dali::ImageDimensions *)jarg2;
103222   if (!argp2) {
103223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103224     return 0;
103225   }
103226   arg2 = *argp2;
103227   arg3 = (Dali::FittingMode::Type)jarg3;
103228   {
103229     try {
103230       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103231     } catch (std::out_of_range& e) {
103232       {
103233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103234       };
103235     } catch (std::exception& e) {
103236       {
103237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103238       };
103239     } catch (...) {
103240       {
103241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103242       };
103243     }
103244   }
103245   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103246
103247   return jresult;
103248 }
103249
103250
103251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103252   void * jresult ;
103253   std::string *arg1 = 0 ;
103254   Dali::ImageDimensions arg2 ;
103255   Dali::ImageDimensions *argp2 ;
103256   Dali::ImageDimensions result;
103257
103258   if (!jarg1) {
103259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103260     return 0;
103261   }
103262   std::string arg1_str(jarg1);
103263   arg1 = &arg1_str;
103264   argp2 = (Dali::ImageDimensions *)jarg2;
103265   if (!argp2) {
103266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103267     return 0;
103268   }
103269   arg2 = *argp2;
103270   {
103271     try {
103272       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103273     } catch (std::out_of_range& e) {
103274       {
103275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103276       };
103277     } catch (std::exception& e) {
103278       {
103279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103280       };
103281     } catch (...) {
103282       {
103283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103284       };
103285     }
103286   }
103287   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103288
103289   return jresult;
103290 }
103291
103292
103293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103294   void * jresult ;
103295   std::string *arg1 = 0 ;
103296   Dali::ImageDimensions result;
103297
103298   if (!jarg1) {
103299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103300     return 0;
103301   }
103302   std::string arg1_str(jarg1);
103303   arg1 = &arg1_str;
103304   {
103305     try {
103306       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103307     } catch (std::out_of_range& e) {
103308       {
103309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103310       };
103311     } catch (std::exception& e) {
103312       {
103313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103314       };
103315     } catch (...) {
103316       {
103317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103318       };
103319     }
103320   }
103321   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103322
103323   return jresult;
103324 }
103325
103326
103327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103328   void * jresult ;
103329   std::string *arg1 = 0 ;
103330   Dali::ImageDimensions arg2 ;
103331   Dali::FittingMode::Type arg3 ;
103332   Dali::SamplingMode::Type arg4 ;
103333   bool arg5 ;
103334   Dali::ImageDimensions *argp2 ;
103335   Dali::Devel::PixelBuffer result;
103336
103337   if (!jarg1) {
103338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103339     return 0;
103340   }
103341   std::string arg1_str(jarg1);
103342   arg1 = &arg1_str;
103343   argp2 = (Dali::ImageDimensions *)jarg2;
103344   if (!argp2) {
103345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103346     return 0;
103347   }
103348   arg2 = *argp2;
103349   arg3 = (Dali::FittingMode::Type)jarg3;
103350   arg4 = (Dali::SamplingMode::Type)jarg4;
103351   arg5 = jarg5 ? true : false;
103352   {
103353     try {
103354       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103355     } catch (std::out_of_range& e) {
103356       {
103357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103358       };
103359     } catch (std::exception& e) {
103360       {
103361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103362       };
103363     } catch (...) {
103364       {
103365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103366       };
103367     }
103368   }
103369   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103370
103371   return jresult;
103372 }
103373
103374
103375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103376   void * jresult ;
103377   std::string *arg1 = 0 ;
103378   Dali::ImageDimensions arg2 ;
103379   Dali::FittingMode::Type arg3 ;
103380   Dali::SamplingMode::Type arg4 ;
103381   Dali::ImageDimensions *argp2 ;
103382   Dali::Devel::PixelBuffer result;
103383
103384   if (!jarg1) {
103385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103386     return 0;
103387   }
103388   std::string arg1_str(jarg1);
103389   arg1 = &arg1_str;
103390   argp2 = (Dali::ImageDimensions *)jarg2;
103391   if (!argp2) {
103392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103393     return 0;
103394   }
103395   arg2 = *argp2;
103396   arg3 = (Dali::FittingMode::Type)jarg3;
103397   arg4 = (Dali::SamplingMode::Type)jarg4;
103398   {
103399     try {
103400       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103401     } catch (std::out_of_range& e) {
103402       {
103403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103404       };
103405     } catch (std::exception& e) {
103406       {
103407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103408       };
103409     } catch (...) {
103410       {
103411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103412       };
103413     }
103414   }
103415   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103416
103417   return jresult;
103418 }
103419
103420
103421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103422   void * jresult ;
103423   std::string *arg1 = 0 ;
103424   Dali::ImageDimensions arg2 ;
103425   Dali::FittingMode::Type arg3 ;
103426   Dali::ImageDimensions *argp2 ;
103427   Dali::Devel::PixelBuffer result;
103428
103429   if (!jarg1) {
103430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103431     return 0;
103432   }
103433   std::string arg1_str(jarg1);
103434   arg1 = &arg1_str;
103435   argp2 = (Dali::ImageDimensions *)jarg2;
103436   if (!argp2) {
103437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103438     return 0;
103439   }
103440   arg2 = *argp2;
103441   arg3 = (Dali::FittingMode::Type)jarg3;
103442   {
103443     try {
103444       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103445     } catch (std::out_of_range& e) {
103446       {
103447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103448       };
103449     } catch (std::exception& e) {
103450       {
103451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103452       };
103453     } catch (...) {
103454       {
103455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103456       };
103457     }
103458   }
103459   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103460
103461   return jresult;
103462 }
103463
103464
103465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103466   void * jresult ;
103467   std::string *arg1 = 0 ;
103468   Dali::ImageDimensions arg2 ;
103469   Dali::ImageDimensions *argp2 ;
103470   Dali::Devel::PixelBuffer result;
103471
103472   if (!jarg1) {
103473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103474     return 0;
103475   }
103476   std::string arg1_str(jarg1);
103477   arg1 = &arg1_str;
103478   argp2 = (Dali::ImageDimensions *)jarg2;
103479   if (!argp2) {
103480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103481     return 0;
103482   }
103483   arg2 = *argp2;
103484   {
103485     try {
103486       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103487     } catch (std::out_of_range& e) {
103488       {
103489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103490       };
103491     } catch (std::exception& e) {
103492       {
103493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103494       };
103495     } catch (...) {
103496       {
103497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103498       };
103499     }
103500   }
103501   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103502
103503   return jresult;
103504 }
103505
103506
103507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103508   void * jresult ;
103509   std::string *arg1 = 0 ;
103510   Dali::Devel::PixelBuffer result;
103511
103512   if (!jarg1) {
103513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103514     return 0;
103515   }
103516   std::string arg1_str(jarg1);
103517   arg1 = &arg1_str;
103518   {
103519     try {
103520       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103521     } catch (std::out_of_range& e) {
103522       {
103523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103524       };
103525     } catch (std::exception& e) {
103526       {
103527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103528       };
103529     } catch (...) {
103530       {
103531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103532       };
103533     }
103534   }
103535   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103536
103537   return jresult;
103538 }
103539
103540
103541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
103542   void * jresult ;
103543   Dali::Toolkit::WebView result;
103544
103545   {
103546     try {
103547       result = Dali::Toolkit::WebView::New();
103548     } catch (std::out_of_range& e) {
103549       {
103550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103551       };
103552     } catch (std::exception& e) {
103553       {
103554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103555       };
103556     } catch (Dali::DaliException e) {
103557       {
103558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103559       };
103560     } catch (...) {
103561       {
103562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103563       };
103564     }
103565   }
103566   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103567   return jresult;
103568 }
103569
103570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
103571   void * jresult ;
103572   Dali::Toolkit::WebView result;
103573
103574   std::string *arg1;
103575   std::string *arg2;
103576
103577   if (!jarg1) {
103578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
103579     return 0;
103580   }
103581   if (!jarg2) {
103582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
103583     return 0;
103584   }
103585
103586   std::string jarg1_str = std::string(jarg1);
103587   std::string jarg2_str = std::string(jarg2);
103588
103589   arg1 = &jarg1_str;
103590   arg2 = &jarg2_str;
103591
103592   {
103593     try {
103594       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
103595     } catch (std::out_of_range& e) {
103596       {
103597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103598       };
103599     } catch (std::exception& e) {
103600       {
103601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103602       };
103603     } catch (Dali::DaliException e) {
103604       {
103605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103606       };
103607     } catch (...) {
103608       {
103609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103610       };
103611     }
103612   }
103613   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103614   return jresult;
103615 }
103616
103617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
103618   void * jresult ;
103619   Dali::Toolkit::WebView *arg1 = 0 ;
103620   Dali::Toolkit::WebView *result = 0 ;
103621
103622   arg1 = (Dali::Toolkit::WebView *)jarg1;
103623   if (!arg1) {
103624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103625     return 0;
103626   }
103627   {
103628     try {
103629       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
103630     } catch (std::out_of_range& e) {
103631       {
103632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103633       };
103634     } catch (std::exception& e) {
103635       {
103636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103637       };
103638     } catch (Dali::DaliException e) {
103639       {
103640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103641       };
103642     } catch (...) {
103643       {
103644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103645       };
103646     }
103647   }
103648   jresult = (void *)result;
103649   return jresult;
103650 }
103651
103652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
103653   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103654   arg1 = (Dali::Toolkit::WebView *)jarg1;
103655   {
103656     try {
103657       delete arg1;
103658     } catch (std::out_of_range& e) {
103659       {
103660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103661       };
103662     } catch (std::exception& e) {
103663       {
103664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103665       };
103666     } catch (Dali::DaliException e) {
103667       {
103668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103669       };
103670     } catch (...) {
103671       {
103672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103673       };
103674     }
103675   }
103676 }
103677
103678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103679   void * jresult ;
103680   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103681   Dali::Toolkit::WebView *arg2 = 0 ;
103682   Dali::Toolkit::WebView *result = 0 ;
103683
103684   arg1 = (Dali::Toolkit::WebView *)jarg1;
103685   arg2 = (Dali::Toolkit::WebView *)jarg2;
103686   if (!arg2) {
103687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103688     return 0;
103689   }
103690   {
103691     try {
103692       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103693     } catch (std::out_of_range& e) {
103694       {
103695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103696       };
103697     } catch (std::exception& e) {
103698       {
103699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103700       };
103701     } catch (Dali::DaliException e) {
103702       {
103703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103704       };
103705     } catch (...) {
103706       {
103707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103708       };
103709     }
103710   }
103711   jresult = (void *)result;
103712   return jresult;
103713 }
103714
103715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103716   void * jresult ;
103717   Dali::BaseHandle arg1 ;
103718   Dali::BaseHandle *argp1 ;
103719   Dali::Toolkit::WebView result;
103720
103721   argp1 = (Dali::BaseHandle *)jarg1;
103722   if (!argp1) {
103723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103724     return 0;
103725   }
103726   arg1 = *argp1;
103727   {
103728     try {
103729       result = Dali::Toolkit::WebView::DownCast(arg1);
103730     } catch (std::out_of_range& e) {
103731       {
103732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103733       };
103734     } catch (std::exception& e) {
103735       {
103736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103737       };
103738     } catch (Dali::DaliException e) {
103739       {
103740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103741       };
103742     } catch (...) {
103743       {
103744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103745       };
103746     }
103747   }
103748   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103749   return jresult;
103750 }
103751
103752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103753   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103754   std::string *arg2;
103755
103756   arg1 = (Dali::Toolkit::WebView *)jarg1;
103757
103758   if (!jarg2) {
103759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103760     return;
103761   }
103762
103763   std::string jarg2str = std::string(jarg2);
103764   arg2 = &jarg2str;
103765   {
103766     try {
103767       (arg1)->LoadUrl((std::string const &)*arg2);
103768     } catch (std::out_of_range& e) {
103769       {
103770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103771       };
103772     } catch (std::exception& e) {
103773       {
103774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103775       };
103776     } catch (Dali::DaliException e) {
103777       {
103778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103779       };
103780     } catch (...) {
103781       {
103782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103783       };
103784     }
103785   }
103786 }
103787
103788 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103789   char * jresult ;
103790   std::string result;
103791
103792   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103793
103794   arg1 = (Dali::Toolkit::WebView *)jarg1;
103795   {
103796     try {
103797       result = arg1->GetUrl();
103798     } catch (std::out_of_range& e) {
103799       {
103800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103801       };
103802     } catch (std::exception& e) {
103803       {
103804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103805       };
103806     } catch (Dali::DaliException e) {
103807       {
103808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103809       };
103810     } catch (...) {
103811       {
103812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103813       };
103814     }
103815   }
103816
103817   jresult = SWIG_csharp_string_callback((&result)->c_str());
103818   return jresult;
103819 }
103820
103821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103822   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103823   std::string *arg2;
103824
103825   arg1 = (Dali::Toolkit::WebView *)jarg1;
103826   if (!jarg2) {
103827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103828     return;
103829   }
103830   std::string jarg2str = std::string(jarg2);
103831   arg2 = &jarg2str;
103832   {
103833     try {
103834       (arg1)->LoadHTMLString((std::string const &)*arg2);
103835     } catch (std::out_of_range& e) {
103836       {
103837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103838       };
103839     } catch (std::exception& e) {
103840       {
103841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103842       };
103843     } catch (Dali::DaliException e) {
103844       {
103845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103846       };
103847     } catch (...) {
103848       {
103849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103850       };
103851     }
103852   }
103853 }
103854
103855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103856   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103857
103858   arg1 = (Dali::Toolkit::WebView *)jarg1;
103859   {
103860     try {
103861       (arg1)->Reload();
103862     } catch (std::out_of_range& e) {
103863       {
103864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103865       };
103866     } catch (std::exception& e) {
103867       {
103868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103869       };
103870     } catch (Dali::DaliException e) {
103871       {
103872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103873       };
103874     } catch (...) {
103875       {
103876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103877       };
103878     }
103879   }
103880 }
103881
103882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103883   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103884
103885   arg1 = (Dali::Toolkit::WebView *)jarg1;
103886   {
103887     try {
103888       (arg1)->StopLoading();
103889     } catch (std::out_of_range& e) {
103890       {
103891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103892       };
103893     } catch (std::exception& e) {
103894       {
103895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103896       };
103897     } catch (Dali::DaliException e) {
103898       {
103899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103900       };
103901     } catch (...) {
103902       {
103903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103904       };
103905     }
103906   }
103907 }
103908
103909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103910   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103911
103912   arg1 = (Dali::Toolkit::WebView *)jarg1;
103913   {
103914     try {
103915       (arg1)->GoBack();
103916     } catch (std::out_of_range& e) {
103917       {
103918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103919       };
103920     } catch (std::exception& e) {
103921       {
103922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103923       };
103924     } catch (Dali::DaliException e) {
103925       {
103926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103927       };
103928     } catch (...) {
103929       {
103930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103931       };
103932     }
103933   }
103934 }
103935
103936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103937   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103938
103939   arg1 = (Dali::Toolkit::WebView *)jarg1;
103940   {
103941     try {
103942       (arg1)->GoForward();
103943     } catch (std::out_of_range& e) {
103944       {
103945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103946       };
103947     } catch (std::exception& e) {
103948       {
103949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103950       };
103951     } catch (Dali::DaliException e) {
103952       {
103953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103954       };
103955     } catch (...) {
103956       {
103957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103958       };
103959     }
103960   }
103961 }
103962
103963 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103964   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103965   bool ret;
103966
103967   arg1 = (Dali::Toolkit::WebView *)jarg1;
103968   {
103969     try {
103970       ret = (arg1)->CanGoBack();
103971     } catch (std::out_of_range& e) {
103972       {
103973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103974       };
103975     } catch (std::exception& e) {
103976       {
103977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103978       };
103979     } catch (Dali::DaliException e) {
103980       {
103981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103982       };
103983     } catch (...) {
103984       {
103985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103986       };
103987     }
103988   }
103989   return ret;
103990 }
103991
103992 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103993   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103994   bool ret;
103995
103996   arg1 = (Dali::Toolkit::WebView *)jarg1;
103997   {
103998     try {
103999       ret = (arg1)->CanGoForward();
104000     } catch (std::out_of_range& e) {
104001       {
104002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
104003       };
104004     } catch (std::exception& e) {
104005       {
104006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
104007       };
104008     } catch (Dali::DaliException e) {
104009       {
104010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
104011       };
104012     } catch (...) {
104013       {
104014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
104015       };
104016     }
104017   }
104018   return ret;
104019 }
104020
104021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
104022   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104023   std::string *arg2;
104024
104025   arg1 = (Dali::Toolkit::WebView *)jarg1;
104026   if (!jarg2) {
104027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
104028     return;
104029   }
104030   std::string jarg2_str = std::string(jarg2);
104031   arg2 = &jarg2_str;
104032   {
104033     try {
104034       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
104035     } catch (std::out_of_range& e) {
104036       {
104037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104038       };
104039     } catch (std::exception& e) {
104040       {
104041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104042       };
104043     } catch (Dali::DaliException e) {
104044       {
104045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104046       };
104047     } catch (...) {
104048       {
104049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104050       };
104051     }
104052   }
104053 }
104054
104055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
104056   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104057
104058   arg1 = (Dali::Toolkit::WebView *)jarg1;
104059   {
104060     try {
104061       (arg1)->ClearHistory();
104062     } catch (std::out_of_range& e) {
104063       {
104064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104065       };
104066     } catch (std::exception& e) {
104067       {
104068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104069       };
104070     } catch (Dali::DaliException e) {
104071       {
104072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104073       };
104074     } catch (...) {
104075       {
104076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104077       };
104078     }
104079   }
104080 }
104081
104082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
104083   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
104084
104085   arg1 = (Dali::Toolkit::WebView *)jarg1;
104086   {
104087     try {
104088       (arg1)->ClearCache();
104089     } catch (std::out_of_range& e) {
104090       {
104091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104092       };
104093     } catch (std::exception& e) {
104094       {
104095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104096       };
104097     } catch (Dali::DaliException e) {
104098       {
104099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104100       };
104101     } catch (...) {
104102       {
104103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104104       };
104105     }
104106   }
104107 }
104108
104109 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
104110     return (Dali::Toolkit::Control *)jarg1;
104111 }
104112
104113
104114 // Proxy class of WebViewSignal.
104115 // WebViewSignal has an argument of std::string type which is not supported at C# side.
104116 // The purpose of this class is to convert signal argument of string type safely.
104117 class WebViewSignalProxy : public ConnectionTracker
104118 {
104119 public:
104120   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
104121   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
104122   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
104123
104124   WebViewSignalProxy(OriginalSignalType* signal)
104125     : mSignalPtr(signal)
104126   {
104127   }
104128
104129   void Connect(CallbackType csharpCallback)
104130   {
104131     if (mSignalPtr->Empty())
104132     {
104133       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
104134     }
104135     mProxySignal.Connect(csharpCallback);
104136   }
104137
104138   void Disconnect(CallbackType csharpCallback)
104139   {
104140     mProxySignal.Disconnect(csharpCallback);
104141     if (mProxySignal.Empty())
104142     {
104143       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
104144     }
104145   }
104146
104147   bool Empty()
104148   {
104149     return mProxySignal.Empty();
104150   }
104151
104152   std::size_t GetConnectionCount()
104153   {
104154     return mProxySignal.GetConnectionCount();
104155   }
104156
104157   void Emit(Dali::Toolkit::WebView& webview, char* url)
104158   {
104159     if (!mProxySignal.Empty())
104160     {
104161       mProxySignal.Emit(webview, url);
104162     }
104163   }
104164
104165   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
104166   {
104167     // Safe string conversion
104168     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
104169   }
104170
104171 private:
104172   OriginalSignalType* mSignalPtr;
104173   ProxySignalType mProxySignal;
104174 };
104175
104176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
104177   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104178   WebViewSignalProxy* result = NULL;
104179   {
104180     try {
104181       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
104182     } catch (std::out_of_range& e) {
104183       {
104184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104185       };
104186     } catch (std::exception& e) {
104187       {
104188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104189       };
104190     } catch (Dali::DaliException e) {
104191       {
104192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104193       };
104194     } catch (...) {
104195       {
104196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104197       };
104198     }
104199   }
104200   return (void*) result;
104201 }
104202
104203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
104204   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
104205   WebViewSignalProxy* result = NULL;
104206   {
104207     try {
104208       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
104209     } catch (std::out_of_range& e) {
104210       {
104211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104212       };
104213     } catch (std::exception& e) {
104214       {
104215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104216       };
104217     } catch (Dali::DaliException e) {
104218       {
104219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104220       };
104221     } catch (...) {
104222       {
104223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104224       };
104225     }
104226   }
104227   return (void*) result;
104228 }
104229
104230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
104231 {
104232   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
104233   {
104234     try {
104235       delete object;
104236     } catch (std::out_of_range& e) {
104237       {
104238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104239       };
104240     } catch (std::exception& e) {
104241       {
104242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104243       };
104244     } catch (Dali::DaliException e) {
104245       {
104246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104247       };
104248     } catch (...) {
104249       {
104250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104251       };
104252     }
104253   }
104254 }
104255
104256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
104257 {
104258   bool result;
104259   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104260   {
104261     try {
104262       result = (bool)proxy->Empty();
104263     } catch (std::out_of_range& e) {
104264       {
104265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104266       };
104267     } catch (std::exception& e) {
104268       {
104269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104270       };
104271     } catch (Dali::DaliException e) {
104272       {
104273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104274       };
104275     } catch (...) {
104276       {
104277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104278       };
104279     }
104280   }
104281   return (unsigned int) result;
104282 }
104283
104284
104285 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
104286 {
104287   std::size_t result;
104288   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
104289   {
104290     try {
104291       result = arg1->GetConnectionCount();
104292     } catch (std::out_of_range& e) {
104293       {
104294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
104295       };
104296     } catch (std::exception& e) {
104297       {
104298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
104299       };
104300     } catch (Dali::DaliException e) {
104301       {
104302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
104303       };
104304     } catch (...) {
104305       {
104306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
104307       };
104308     }
104309   }
104310   return (unsigned long) result;
104311 }
104312
104313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
104314 {
104315   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104316   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104317   {
104318     try {
104319       proxy->Connect(callback);
104320     } catch (std::out_of_range& e) {
104321       {
104322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104323       };
104324     } catch (std::exception& e) {
104325       {
104326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104327       };
104328     } catch (Dali::DaliException e) {
104329       {
104330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104331       };
104332     } catch (...) {
104333       {
104334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104335       };
104336     }
104337   }
104338 }
104339
104340
104341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
104342   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104343   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::CallbackType) jarg2;
104344   {
104345     try {
104346       proxy->Disconnect(callback);
104347     } catch (std::out_of_range& e) {
104348       {
104349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104350       };
104351     } catch (std::exception& e) {
104352       {
104353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104354       };
104355     } catch (Dali::DaliException e) {
104356       {
104357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104358       };
104359     } catch (...) {
104360       {
104361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104362       };
104363     }
104364   }
104365 }
104366
104367
104368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
104369   if (!jarg2) {
104370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
104371     return ;
104372   }
104373   if (!jarg3) {
104374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
104375     return ;
104376   }
104377
104378   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
104379   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
104380   {
104381     try {
104382       proxy->Emit(*webview, jarg3);
104383     } catch (std::out_of_range& e) {
104384       {
104385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
104386       };
104387     } catch (std::exception& e) {
104388       {
104389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
104390       };
104391     } catch (Dali::DaliException e) {
104392       {
104393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
104394       };
104395     } catch (...) {
104396       {
104397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
104398       };
104399     }
104400   }
104401 }
104402
104403 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
104404   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
104405   char * jresult = SWIG_csharp_string_callback((const char *)result);
104406   return jresult;
104407 }
104408
104409 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
104410   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
104411   return result;
104412 }
104413
104414 #ifdef __cplusplus
104415 }
104416 #endif
104417